实现TCP通信（含地址快速重用介绍）

已于 2024-07-10 11:52:11 修改
阅读量83 收藏
点赞数
文章标签： tcp/ip 网络 服务器
于 2024-04-24 00:52:15 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/jzxnb521/article/details/138120575
版权

地址快速重用

地址快速重用（Address reuse）是指在计算机网络通信中，使用相同的源IP地址和源端口号发送多个不同的数据包。这种技术通常用于加快网络连接的建立和数据传输速度。

在TCP/IP协议中，每个TCP连接都需要独立的四元组（源IP地址、源端口号、目的IP地址、目的端口号）来进行标识和识别。如果使用地址快速重用技术，可以避免频繁地分配和释放端口号，从而加快网络连接建立和数据传输的速度。

需要注意的是，使用地址快速重用技术可能会导致一些安全风险，因为攻击者可以利用相同的源IP地址和源端口号来伪造数据包，进行网络攻击。因此，在实际应用中需要进行一些安全措施来避免这种情况的发生。

在网络编程中，若想使用已被占用的地址和端口，将导致绑定套接字到该地址的操作失败，并返回错误。为了能够成功绑定到被占用的地址和端口，需要进行相应的设置，即启用地址重用功能。

系统默认阻止重复绑定有其道理，而地址重用也有其存在的意义。我们都知道，在网络中传输的消息都有一个最长的存活时间，如果在这个时间段内没有达到没目的地就会被丢弃。在服务器正常关闭与意外崩溃后，在网络中有可能依旧存在以该地址和端口为目的地的信息，操作系统通过保留一段时间的套接字资源让这些滞留在网络中的信息自行消散。这样做是可以防止历史连接过过程中的数据对下一次连接造成干扰和影响，但是却不利于我们高效利用网络资源，尤其是在一些频繁绑定与释放网络任务中，这些暂留的时间会导致产生大量无法被有效利用的网络资源。在具体的网络情景中，我们需要根据需要对是否使用网络重用进行取舍。

        实现地址重用可以使用setsockopt()函数，并指定SO_REUSEADDR 选项。以下是一个开启地址重用功能的例子：

#include <sys/socket.h>
#include <netinet/in.h>
 
int reuse_addr = 1;
setsockopt(socket_fd,SOL_SOCKET,SO_REUSEADDR,&reuse_addr,sizeof(reuse_addr));

下面是对地址重用所使用函数的参数解释：

  • socket_fd：指定要设置选项的套接字文件描述符。
  • SOL_SOCKET：指定选项所属的协议级别，这里是套接字级别。
  • SO_REUSEADDR：指定要设置的选项类型，即地址重用选项。
  • &reuse_addr：传入一个指向存储选项值的变量的指针，这里是启用地址重用
  • sizeof(reuse_addr)：指定选项值的大小。

socket函数 与 通信域

#include <sys/types.h>
#include <sys/socket.h>
int socket(int domain, int type, int protocol);
//-domain: 指定通信域（通信地址族）;
//-type: 指定套接字类型;
//-protocol: 指定协议;

-domain通信地址族：AF_INET: 使用IPv4 互联网协议  AF_INET6: 使用IPv6 互联网协议 ......

-type: 指定套接字类型

TCP唯一对应流式套接字，所以选择SOCK_STREAM(数据报套接字：SOCK_DGRAM)

-protocol: 指定协议 流式套接字唯一对应TCP，所以无需要指定协议，设为0即可

bind函数 与 通信结构体

int bind(int sockfd, const struct sockaddr *addr, socklen_t addrlen);
//-sockfd:socket函数生成的套接字
//-addr:通信结构体
//-addrlen:通信结构体的长度

通信地址族 与 通信结构体的关系

//通用地址族结构体
struct sockaddr {
        sa_family_t sa_family;
        char        sa_data[14];
}

//IPv4地址族结构体
struct sockaddr_in {
        sa_family_t    sin_family; /* 地址族: AF_INET */
        in_port_t      sin_port;   /* 网络字节序的端口号 */
        struct in_addr sin_addr;   /*IP地址结构体 */
};
/* IP地址结构体 */
struct in_addr {
        uint32_t       s_addr;     /* 网络字节序的IP地址 */
};

示例：为套接字fd绑定通信结构体addr：

addr.sin_family = AF_INET;
addr.sin_port = htons(5001); //绑定端口号 主机转网络
addr.sin_addr.s_addr = 0;
bind(fd, (struct sockaddr *)&addr, sizeof(addr) ); //通信结构体绑定到套接字上

listen函数 与 accept函数

/*监听套接字*/
int listen(int sockfd, int backlog);

/*处理客户端发起的连接，生成新的套接字*/
int accept(int sockfd, struct sockaddr *addr, socklen_t *addrlen);
//-sockfd: 函数socket生成的套接字
//-addr:客户端的地址族信息
//-addrlen:地址族结构体的长度

服务器端示例代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>


#define PORT 5001
#define BACKLOG 5

int main(){
        int fd,newfd;
        char buf[BUFSIZ] = {};
        struct sockaddr_in addr;

        fd = socket(AF_INET,SOCK_STREAM,0);
        if(fd<0){
                perror("socket");
                exit(0);
        }

        addr.sin_family = AF_INET;
        addr.sin_port = htons(PORT); //绑定端口号 主机转网络
        addr.sin_addr.s_addr = 0;
        if(bind(fd, (struct sockaddr *)&addr, sizeof(addr) )==-1){ //通信结构体>绑定到套接字上  
                perror("bind");
                exit(0);
        }
        if(listen(fd,BACKLOG) == -1){
                perror("listen");
                exit(0);
        }
        newfd=accept(fd,NULL,NULL);
        if(newfd<0){
                perror("socket");
                exit(0);
        }
        printf("BUFSIZ = %d\n",BUFSIZ);
        read(newfd,buf,BUFSIZ);
        printf("buf = %s\n",buf);
        close(fd);
        return 0;
}

客户端示例代码：

#include <stdio.h>
#include <sys/types.h>
#include <sys/socket.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>


#define PORT 5001
#define BACKLOG 5
#define STR "HELLO WORLD!"

int main(){
        int fd;

        struct sockaddr_in addr;

        fd = socket(AF_INET,SOCK_STREAM,0);
        if(fd<0){
                perror("socket");
                exit(0);
        }

        addr.sin_family = AF_INET;
        addr.sin_port = htons(PORT); //绑定端口号 主机转网络
        addr.sin_addr.s_addr = inet_addr("127.0.0.1");
        if(connect(fd, (struct sockaddr *)&addr, sizeof(addr) )==-1){ //通信结构
体>绑定到套接字上  
                perror("connect");
                exit(0);
        }

        write(fd,STR,sizeof(STR));
        printf("STR = %s\n",STR);
        close(fd);
        return 0;
}

运行截图：

代码优化

客户端：

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

#define BACKLOG 5

int main(int argc, char *argv[])
{
	int fd;
	struct sockaddr_in addr;
	char buf[BUFSIZ] = {};

	if(argc < 3){
		fprintf(stderr, "%s<addr><port>\n", argv[0]);
		exit(0);
	}

	/*创建套接字*/
	fd = socket(AF_INET, SOCK_STREAM, 0);
	if(fd < 0){
		perror("socket");
		exit(0);
	}

	addr.sin_family = AF_INET;
	addr.sin_port = htons( atoi(argv[2]) );
	if ( inet_aton(argv[1], &addr.sin_addr) == 0) {
		fprintf(stderr, "Invalid address\n");
		exit(EXIT_FAILURE);
	}

	/*向服务端发起连接请求*/
	if(connect(fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1){
		perror("connect");
		exit(0);
	}
	while(1){
		printf("Input->");
		fgets(buf, BUFSIZ, stdin);
		write(fd, buf, strlen(buf) );
	}
	close(fd);
	return 0;
}

服务器：

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

#define BACKLOG 5

int main(int argc, char *argv[])
{
	int fd, newfd, ret;
	char buf[BUFSIZ] = {}; //BUFSIZ 8142
	struct sockaddr_in addr;
	
	if(argc < 3){
		fprintf(stderr, "%s<addr><port>\n", argv[0]);
		exit(0);
	}

	/*创建套接字*/
	fd = socket(AF_INET, SOCK_STREAM, 0);
	if(fd < 0){
		perror("socket");
		exit(0);
	}
	addr.sin_family = AF_INET;
	addr.sin_port = htons( atoi(argv[2]) );
	if ( inet_aton(argv[1], &addr.sin_addr) == 0) {
		fprintf(stderr, "Invalid address\n");
		exit(EXIT_FAILURE);
	}

	/*绑定通信结构体*/
	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1){
		perror("bind");
		exit(0);
	}
	/*设置套接字为监听模式*/
	if(listen(fd, BACKLOG) == -1){
		perror("listen");
		exit(0);
	}
	/*接受客户端的连接请求，生成新的用于和客户端通信的套接字*/
	newfd = accept(fd, NULL, NULL);
	if(newfd < 0){
		perror("accept");
		exit(0);
	}
	while(1){
		memset(buf, 0, BUFSIZ);
		ret = read(newfd, buf, BUFSIZ);
		if(ret < 0)
		{
			perror("read");
			exit(0);
		}
		else if(ret == 0)
			break;
		else
			printf("buf = %s\n", buf);
	}
	close(newfd);
	close(fd);
	return 0;
}

TCP多进程并发：（服务器接收多客户端消息）

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>

#define BACKLOG 5  // 最大同时连接请求数

void ClinetHandle(int newfd);  // 声明用于处理客户端的函数

int main(int argc, char *argv[])
{
	int fd, newfd;  // fd 是监听套接字，newfd 是与客户端通信的套接字
	struct sockaddr_in addr, clint_addr;  // 服务器和客户端的地址结构体
	socklen_t addrlen = sizeof(clint_addr);
	
	pid_t pid;  // 用于存放进程ID
	
	if(argc < 3){
		fprintf(stderr, "%s<addr><port>\n", argv[0]);  // 命令行参数错误提示
		exit(0);
	}

	// 创建套接字
	fd = socket(AF_INET, SOCK_STREAM, 0);
	if(fd < 0){
		perror("socket");
		exit(0);
	}
	addr.sin_family = AF_INET;
	addr.sin_port = htons(atoi(argv[2]));  // 设置端口
	if (inet_aton(argv[1], &addr.sin_addr) == 0) {  // 设置IP地址
		fprintf(stderr, "Invalid address\n");
		exit(EXIT_FAILURE);
	}

	// 设置地址重用
	int flag=1, len= sizeof(int); 
	if (setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, len) == -1) { 
		perror("setsockopt"); 
		exit(1); 
	} 
	
	// 绑定套接字
	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr)) == -1){
		perror("bind");
		exit(0);
	}

	// 将套接字设置为监听模式
	if(listen(fd, BACKLOG) == -1){
		perror("listen");
		exit(0);
	}
	while(1){
		// 接受客户端的连接请求
		newfd = accept(fd, (struct sockaddr *)&clint_addr, &addrlen);
		if(newfd < 0){
			perror("accept");
			exit(0);
		}
		// 打印客户端地址和端口信息
		printf("addr:%s port:%d\n", inet_ntoa(clint_addr.sin_addr), ntohs(clint_addr.sin_port));
		
		// 创建子进程来处理客户端
		if((pid = fork()) < 0){
			perror("fork");
			exit(0);
		}else if(pid == 0){  // 子进程
			close(fd);  // 子进程中关闭监听套接字
			ClinetHandle(newfd);  // 处理客户端
			exit(0);
		}
		else
			close(newfd);  // 父进程中关闭通信套接字
	}
	close(fd);  // 关闭监听套接字
	return 0;
}

void ClinetHandle(int newfd){
	int ret;
	char buf[BUFSIZ];  // 数据接收缓冲区
	while(1){
		bzero(buf, BUFSIZ);  // 清空缓冲区
		ret = read(newfd, buf, BUFSIZ);  // 从套接字读取数据
		if(ret < 0)
		{
			perror("read");
			exit(0);
		}
		else if(ret == 0)  // 对端关闭连接
			break;
		else
			printf("buf = %s\n", buf);  // 打印接收到的数据
	}
	close(newfd);  // 关闭与客户端的连接
}

注解：

  1. 头文件:

    • stdio.h：提供输入输出函数。
    • sys/socket.h 和 sys/types.h：提供套接字功能支持。
    • stdlib.h：提供各种常用的库函数，如 exit。
    • arpa/inet.h：提供IP地址转换函数。
    • unistd.h：提供对 POSIX 操作系统 API 的访问功能，如 read、write 和 close。
    • string.h 和 strings.h：提供字符串处理函数。

  2. 宏定义:

    • BACKLOG：监听队列中最大的连接数。

  3. 主函数 (main):

    • 解析命令行参数，确定服务器监听的 IP 地址和端口号。
    • 创建一个 TCP 套接字。
    • 设置套接字选项，使得地址（IP和端口）可以被重用，这对于服务器程序重启是很有用的。
    • 将套接字绑定到一个地址和端口。
    • 将套接字设置为监听状态，准备接受连接请求。
    • 通过 accept 函数循环等待客户端的连接请求。每当接受一个连接，就打印客户端的地址信息。
    • 使用 fork 创建一个新的进程来处理客户端请求，父进程关闭新的套接字描述符，子进程关闭监听套接字，并调用 ClinetHandle 函数来处理客户端。

  4. ClinetHandle 函数:

    • 这个函数用于处理客户端发来的数据。
    • 使用 read 函数从套接字读取数据，并将读取的数据打印出来。
    • 如果 read 函数返回 0，表示对端已经关闭了连接，因此跳出循环。
    • 使用 bzero 函数清零接收缓冲区，以便重新使用。

  5. 错误处理:

    • 程序中包含多个错误检查点，如套接字创建失败、绑定失败、监听失败等，都会输出错误信息并退出程序。

僵尸进程处理

#include <stdio.h>
#include <sys/socket.h>
#include <sys/types.h>
#include <stdlib.h>
#include <arpa/inet.h>
#include <unistd.h>
#include <string.h>
#include <strings.h>
#include <signal.h>
#include <sys/wait.h>

#define BACKLOG 5

//信号处理函数
void SigHandle(int sig){
	if(sig == SIGCHLD){
		printf("client exited\n");
		wait(NULL);
	}
}
void ClinetHandle(int newfd);
int main(int argc, char *argv[])
{
	int fd, newfd;
	struct sockaddr_in addr, clint_addr;
	socklen_t addrlen = sizeof(clint_addr);

#if 0
	struct sigaction act; 
	act.sa_handler = SigHandle;
	act.sa_flags = SA_RESTART; //不启用的话 accept函数会执行失败
	sigemptyset(&act.sa_mask);
	sigaction(SIGCHLD, &act, NULL);
#else
	signal(SIGCHLD, SigHandle);
#endif

	pid_t pid;
	
	if(argc < 3){
		fprintf(stderr, "%s<addr><port>\n", argv[0]);
		exit(0);
	}

	/*创建套接字*/
	fd = socket(AF_INET, SOCK_STREAM, 0);
	if(fd < 0){
		perror("socket");
		exit(0);
	}
	addr.sin_family = AF_INET;
	addr.sin_port = htons( atoi(argv[2]) );
	if ( inet_aton(argv[1], &addr.sin_addr) == 0) {
		fprintf(stderr, "Invalid address\n");
		exit(EXIT_FAILURE);
	}

	/*地址快速重用*/
	int flag=1,len= sizeof (int); 
	if ( setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, len) == -1) { 
		      perror("setsockopt"); 
			        exit(1); 
	} 
	/*绑定通信结构体*/
	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1){
		perror("bind");
		exit(0);
	}
	/*设置套接字为监听模式*/
	if(listen(fd, BACKLOG) == -1){
		perror("listen");
		exit(0);
	}
	while(1){
		/*接受客户端的连接请求，生成新的用于和客户端通信的套接字*/
		newfd = accept(fd, (struct sockaddr *)&clint_addr, &addrlen);
		if(newfd < 0){
			perror("accept");
			exit(0);
		}
		printf("addr:%s port:%d\n", inet_ntoa(clint_addr.sin_addr), ntohs(clint_addr.sin_port) );
		if( (pid = fork() ) < 0){
			perror("fork");
			exit(0);
		}else if(pid == 0){
			close(fd);
			ClinetHandle(newfd);
			exit(0);
		}
		else
			close(newfd);
	}
	close(fd);
	return 0;
}
void ClinetHandle(int newfd){
	int ret;
	char buf[BUFSIZ] = {};
	while(1){
		//memset(buf, 0, BUFSIZ);
		bzero(buf, BUFSIZ);
		ret = read(newfd, buf, BUFSIZ);
		if(ret < 0)
		{
			perror("read");
			exit(0);
		}
		else if(ret == 0)
			break;
		else
			printf("buf = %s\n", buf);
	}
	close(newfd);
}

TCP多线程并发

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

#define BACKLOG 5 // 最大的等待连接队列长度

void *ClinetHandle(void *arg);  // 线程函数声明

int main(int argc, char *argv[])
{
	int fd, newfd; // fd 是监听套接字，newfd 是客户端连接套接字
	struct sockaddr_in addr, clint_addr;  // 服务器和客户端的地址结构
	pthread_t tid;
	socklen_t addrlen = sizeof(clint_addr);
	
	if(argc < 3){
		fprintf(stderr, "%s<addr><port>\n", argv[0]);  // 检查命令行参数
		exit(0);
	}

	//创建套接字
	fd = socket(AF_INET, SOCK_STREAM, 0);
	if(fd < 0){
		perror("socket");
		exit(0);
	}
	addr.sin_family = AF_INET;
	addr.sin_port = htons( atoi(argv[2]));   // 设置端口号
	if ( inet_aton(argv[1], &addr.sin_addr) == 0) {   // 设置IP地址
		fprintf(stderr, "Invalid address\n");
		exit(EXIT_FAILURE);
	}

	//设置地址快速重用
	int flag=1,len= sizeof (int); 
	if ( setsockopt(fd, SOL_SOCKET, SO_REUSEADDR, &flag, len) == -1) { 
		      perror("setsockopt"); 
			        exit(1); 
	} 

	// 绑定套接字
	if(bind(fd, (struct sockaddr *)&addr, sizeof(addr) ) == -1){
		perror("bind");
		exit(0);
	}
	// 设置套接字为监听模式
	if(listen(fd, BACKLOG) == -1){
		perror("listen");
		exit(0);
	}
	while(1){
		//接受客户端的连接请求，生成新的用于和客户端通信的套接字
		newfd = accept(fd, (struct sockaddr *)&clint_addr, &addrlen);
		if(newfd < 0){
			perror("accept");
			exit(0);
		}

// 打印客户端地址信息
		printf("addr:%s port:%d\n", inet_ntoa(clint_addr.sin_addr), ntohs(clint_addr.sin_port) );
		pthread_create(&tid, NULL, ClinetHandle, &newfd);// 创建一个线程来处理客户端请求
		pthread_detach(tid); //设置分离属性，使线程结束时自动回收资源
	}
	close(fd);  // 关闭监听套接字
	return 0;
}

void *ClinetHandle(void *arg){
	int ret;
	char buf[BUFSIZ] = {};  // 接收缓冲区
	int newfd = *(int *)arg;  // 从参数中获取套接字描述符
	while(1){
		//memset(buf, 0, BUFSIZ);
		bzero(buf, BUFSIZ);    // 清空缓冲区
		ret = read(newfd, buf, BUFSIZ);    // 读取客户端数据
		if(ret < 0)
		{
			perror("read");
			exit(0);
		}
		else if(ret == 0)   // 客户端关闭连接
			break;
		else
			printf("buf = %s\n", buf);   // 输出接收到的数据
	}  
	printf("client exited\n");    // 客户端退出通知
	close(newfd);    // 关闭与客户端的连接
	return NULL;
}
  1. 多线程处理: 使用 pthread_create 创建一个新的线程来处理每个新的客户端连接。这使得服务器能够同时处理多个客户端。
  2. 线程函数 ClinetHandle: 这个函数负责从客户端读取数据并打印出来，直到客户端关闭连接。
  3. 资源管理: 使用 pthread_detach 使得线程在结束时自动释放所有资源，不需要主线程进行回收。

  4. TCP Socket 操作: 程序中使用了 socket(), bind(), listen(), 和 accept() 函数来完成 TCP 套接字的创建、绑定、监听和接受连接的基本流程。

  5. 地址重用: 使用 setsockopt() 设置 SO_REUSEADDR 选项，这允许服务器快速重启而不必等待套接字在TIME_WAIT状态消失，避免了"Address already in use"错误。

  6. 错误处理: 在关键操作后检查返回值，如套接字创建、绑定、监听等，出现错误时使用 perror() 打印错误信息并退出程序。这是处理网络编程中可能发生的各种异常情况的标准做法。

  7. 客户端信息打印: 当客户端连接成功时，服务器会打印出客户端的 IP 地址和端口号，这有助于跟踪连接到服务器的客户端。

  8. 数据读取与打印: 在 ClinetHandle 函数中，通过循环调用 read() 从客户端套接字读取数据，并打印出来。如果 read() 返回0，意味着客户端已经关闭连接，此时跳出循环，关闭套接字，并结束线程。

  9. 线程的创建与管理: pthread_create() 被用来创建新线程，线程 ID 存储在 tid 变量中。使用 pthread_detach() 将线程设置为分离状态，这样一旦线程执行完成后，其资源会自动被系统回收。

  10. 命令行参数: 程序依赖命令行参数来获得监听的 IP 地址和端口号。如果参数数量不正确，程序会提示正确的用法并退出。

执行截图：

jzxnb521
关注
TCP端口复用
蜜汁程序员的博客
10-31 9989
  TCP端口复用 用于TCP穿透之中。 为了验证真实性，写了一个小例子。 试验了一个端口是否可以同时进行监听接收和发送 ，创建了四个进程。 原理： 1.设置::setsockopt(accept_fd, SOL_SOCKET, SO_REUSEADDR, &amp;opt, sizeof (opt)); 2.  ::setsockopt(accept_fd, SOL_SOCKET, ...
利用负载均衡优化和加速HTTP应用
首席技术执行官CTO(Chief Technology Officer)|技术总监--邓斌博客
10-03 1343
1. 负载均衡技术简介　　现代企业信息化应用越来越多的采用B/S应用架构来承载企业的关键业务，因此，确保这些任务的可靠运行就变得日益重要。随着越来越多的企业实施数据集中，应用的扩展性、安全性和可靠性也越来越受到企业的重视。　　负载均衡技术通过设置虚拟服务器IP（VIP），将后端多
TCP端口重用[转]
热门推荐
余璜的技术博客
06-03 1万+
<br />原文：http://hi.baidu.com/liaimin/blog/item/07f1fdfa521ff0dbb58f315f.html<br /> <br /> <br />在以前的文章中，我曾经引用过一篇端口重用与端口独占程序设计。但是，后来我发现其中有一点写的不清楚，为清视听，善意为作者添加一点. setsockopt()中的第四个参数是端口重用与否的标志，为1则可重用，否则，禁止重用。所以，上面那篇文章应该加一句：cflag=1;<br /><br />隐患 3．地址使用错误（E
谈谈地址重用
m0_49806738的博客
08-02 227
在服务器正常关闭与意外崩溃后，在网络中有可能依旧存在以该地址和端口为目的地的信息，操作系统通过保留一段时间的套接字资源让这些滞留在网络中的信息自行消散。这样做是可以防止历史连接过过程中的数据对下一次连接造成干扰和影响，但是却不利于我们高效利用网络资源，尤其是在一些频繁绑定与释放网络任务中，这些暂留的时间会导致产生大量无法被有效利用的网络资源。在网络编程中，若想使用已被占用的地址和端口，将导致绑定套接字到该地址的操作失败，并返回错误。：传入一个指向存储选项值的变量的指针，这里是启用地址重用。
socket地址和端口重用（造成bind出错）
飞翔的大象
07-03 6837
其实这个问题在 Richard Stevens 的《 Unix 网络编程指南》卷一里有很详细的 解答 ( 中文版 P166-168 页 ) 。这里我只是写几个基本的例子来验证这个问题。      首先声明一个问题：当两个 socket 的 address 和 port 相冲突，而你又想重用地 址和端口，则旧的 socket 和新的 socket 都要已经被设置了 SO_REUSEADD
地址重用REUSEADDR
weixin_33918114的博客
07-10 688
一个socket连接断开后会进入TIME_WAIT，大概有几十秒，这个时候端口是无法使用的，如果不设定地址重用，就会报错，说端口占用。 创建一个socket实例后，在对这个实例进行地址绑定前，要设定地址重用。 server = socket.socket(socket.AF_INET,socket.SOCK_STREAM) server.setsockopt(socket.SOL_S...
使用C语言实现服务器/客户端的TCP通信
03-29
在本文中，我们将深入探讨如何使用C语言实现服务器和客户端之间的TCP通信。TCP（Transmission Control Protocol）是一种面向连接的协议，提供可靠的数据传输服务，广泛应用于互联网中的各种应用层协议，如HTTP、...
MFC:实现TCP通信，基础短信、文件传输功能
最新发布
09-02
在MFC中实现TCP通信，我们需要使用Winsock，这是Windows操作系统提供的网络编程接口。首先，我们需要包含必要的头文件`<winsock2.h>`和`<afxsock.h>`，并确保链接到`ws2_32.lib`库。 1. **初始化Winsock**： 在...
Python TCP通信客户端服务端代码实例
09-18
通过这两个示例，我们可以看到TCP通信的基本流程：客户端连接到服务器，发送数据，然后接收服务器的响应。服务器则监听连接，接受新的客户端连接，接收并处理客户端的数据。在实际应用中，我们可能需要处理更复杂的...
TCP-P2P.rar_P2P nat实现C++_TCP 打洞 _p2p TCP_tcp_打洞
09-24
描述中的“TCP实现P2P通信、TCP穿越NAT的方法、TCP打洞（附源代码）.doc”进一步确认了这个压缩包包含了一篇文档，详细介绍了如何通过TCP协议进行P2P通信，NAT穿越的技术以及TCP打洞的实践方法，并且提供了源代码。...
2. TCP/UDP 允许重用本地地址
其木王·王子的博客
01-17 2253
TCP/UDP 允许重用本地地址 最近测试 TCP 通信，发现在服务器和客户端正常通信时，手动异常关闭 server 端进程，再次运行开启 server 端程序会在 bind 函数位置报错，造成无法连接。 查阅资料后发现应该是地址或端口冲突了，尝试在 bind 函数前添加 setsockopt 函数增加复用功能. 经过修改测试，重用本地端口未能解决该问题，设置重用本地地址可以解决。 iRet = setsockopt(sockFd, SOL_SOCKET, SO_REUSEADDR, &iRet,
【TCP】端口复用
Guojiahui的博客
05-23 531
因为，TCP连接没有完全断开指的是connfd（127.0.0.1:6666）没有完全断开，而我们重新监听的是lis-tenfd（0.0.0.0:6666），虽然是占用同一个端口，但IP地址不同，connfd对应的是与某个客户端通讯的一个具体的IP地址，而listenfd对应的是wildcard address。解决这个问题的方法是使用setsockopt()设置socket描述符的选项SO_REUSEADDR为1，表示允许创建端口号相同但IP地址不同的多个socket描述符。
tcp 端口复用与惊群效应（REUSEADDR、REUSEPORT）
zhc的博客
02-16 4736
我在之前的一篇文章中，介绍了我在之前的项目中遇到的端口复用，windows 的udp里端口复用导致了一个bug,具体的链接参考如下： 关于Socket中端口复用_zhc的博客-CSDN博客_socket端口复用 而我现在是想总结一下，linux下的情况，想从头再梳理下，REUSEADDR 和 REUSEPORT的作用。 1.SO_REUSEADDR 是为了解决time_wait问题而产生的 SO_REUSEADDR 它的作用是当服务器端主动断开链接的时候，处在timewait阶段大约60秒钟，服
TIME-WAIT sockets重新用于新的TCP连接
qq_43753286的博客
01-11 1456
net.ipv4.tcp_tw_reuse = 0 表示开启重用。允许将TIME-WAIT sockets重新用于新的TCP连接，默认为0，表示关闭 net.ipv4.tcp_tw_recycle = 0 表示开启TCP连接中TIME-WAIT sockets的快速回收，默认为0，表示关闭
TCP连接建立系列 — 客户端的端口选取和重用
weixin_30318645的博客
08-15 300
主要内容：connect()时的端口选取和端口重用。 内核版本：3.15.2 我的博客：http://blog.csdn.net/zhangskd 端口选取 connect()时本地端口是如何选取的呢？ 如果用户已经绑定了端口，就使用绑定的端口。 如果用户没有绑定端口，则让系统自动选取，策略如下： 1. 获取端口的取值区间，以及区间内端口的个数。 2. 根据初...
Linux TCP 服务器编程（五）:端口重用及TIME_WAIT
程序猿的挨踢人生
01-01 4046
上一节说到设置套接字选项的问题，我们这一节主要处理上一节说的“Address already in use”问题，这个问题通过设置设置一个套接字选项来解决。 这个错误提示是在bind函数调用时发生的，bind函数经常遇到这个问题：试图绑定一个已经在使用的端口。但是我们已经明确关闭进程了，这是有套接字状态TIME_WAIT引起的，该状态在套接字关闭后几分钟仍保留，在TIME_WAIT状态退出之后，
TCP网络套接字ServerSocket端口重用SO _ REUSEADDR
YoungLittleT的博客
04-13 428
_ REUSEADDR套接字选项允许套接字强制绑定到另一个套接字使用的端口。第二个套接字调用setsockopt，并将optname参数设置为，并将optval参数设置为布尔值TRUE，然后 _在与原始套接字相同的端口上调用绑定。第二个套接字成功绑定后，绑定到该端口的所有套接字的行为都不确定。例如，如果同一个端口上的所有套接字都提供 TCP 服务，则通过该端口的任何传入 TCP 连接请求均无法保证由正确的套接字处理—行为是不确定的。恶意程序可以使用_ REUSEADDR将已...
tcp状态/半关闭/端口复用
tecoes的博客
05-04 1130
表示初始状态。该状态表示服务器端的某个SOCKET处于监听状态，可以接受连接。这个状态与SYN_RCVD遥相呼应，当客户端SOCKET执行CONNECT连接时，它首先发送SYN报文，随即进入到了SYN_SENT状态，并等待服务端的发送三次握手中的第2个报文。SYN_SENT状态表示客户端已发送SYN报文。该状态表示接收到SYN报文，在正常情况下，这个状态是服务器端的SOCKET在建立TCP连接时的三次握手会话过程中的一个中间状态，很短暂。
QT tcp端口可重用问题
m_benpaodewoniu的博客
07-09 453
【代码】QT tcp端口可重用问题。
C语言实现TCP/IP套接字通信教程
本资源主要介绍了如何使用C语言编写基础的TCP/IP套接字通信程序。 首先，服务端的编程涉及以下关键步骤： 1. **初始化Windows Sockets (Winsock) 库**： 通过调用`WSAStartup`函数，传入所需的Winsock版本号...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值