回射客户-服务器模型（4）

原創 零下10度C_zjw 2020-06-19 20:13

由于TCP是一种基于字节流的传输，属于无边界传输，所以它不能够处理消息与消息之间的边界问题，因此存在粘包问题。

如下图所示：


M1和M2是从主机A传送到主机B的两条消息，那么中间可能有几种传输情况：

a. 两条消息刚好分别完整的传输；

b. 先传输M1和M2的一部分，然后M2的另一部分单独传输；

c. 先传输M1的一部分，然后M1的另一部分和M2一起传输；


粘包产生的原因：


有这几个原因会导致粘包问题：

a. 应用进程缓冲区的大小大于套接口缓冲区的大小，因此缓冲区中的数据一次性发送不完，产生粘包；

b. TCP层传递的数据段的最大限制为MSS，因此高层的数据如果超过这个值，也需要进行分割处理；

c. 链路层最大传输单元为MTU，因此，当上层的数据包的大小超过该值，需要分片；

d. 其他的导致粘包问题，比如TCP的流量控制，拥塞控制，延迟发送机制等都有可能导致粘包问题；


粘包解决方案：

a. 本质上是要在应用层维护消息与消息的边界；

b. 发送定长包（让数据以定长的方式发送和接收）；

c. 包尾加\r\n等分割符；

d. 设计更复杂的应用层协议；


下面我们以定长包的方式发送和接收数据包，主要封装了readn和writen函数。

服务器端：echosrv.c

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

#define ERR_EXIT(m)	\
	do	\
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	}while(0)

struct package{
	int len;
	char buf[1024];
};

ssize_t readn(int fd, void* buf, size_t count)
{
	//由于不能保证一次能够读取count个字节
	//因此我们需要循环进行读取
	//直到读取的字节数为count
	size_t nleft = count;
	ssize_t nread;
	char* bufp = (char*)buf;
	while(nleft > 0)
	{
		if((nread = read(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)//如果信号中断
				continue;
			return -1;
		}
		if(nread == 0)
			//表示对等方关闭，这里直接返回
			return count-nleft;
		nleft -= nread;//每次读取后剩余的字节数
		bufp += nread;
	}
	return count;
}

ssize_t writen(int fd, void* buf, size_t count)
{
	//我们每次希望写入的字节数为count
	size_t nleft = count;
	ssize_t nwritten;
	char* bufp = (char*)buf;
 	while(nleft > 0)
	{
		if((nwritten = write(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		if(nwritten == 0)
			//什么都没发生
			continue;
		nleft -= nwritten;//每次写后剩余要写的字节数
		bufp += nwritten;
	}
	return count;
}

void do_service(int conn)
{
	struct package recvbuf;
	int n;
	while(1)
	{
		memset(&recvbuf, 0, sizeof(recvbuf));
		//包头与包体分开读取
		//先读取包头4个字节,进而确定包体的长度
		int ret = readn(conn,  &recvbuf.len, 4);
		if(ret == -1)
			ERR_EXIT("read failure");
		else if(ret < 4)
		{
			printf("client close\n");
			break;
		}

		//再读取包体
		//包体的长度n存放在结构体的len中
		n = ntohl(recvbuf.len);
		ret = readn(conn, recvbuf.buf, n);
		if(ret == -1)
			ERR_EXIT("read failure");
		else if(ret < n)
		{
			printf("client close\n");
			break;
		}
		fputs(recvbuf.buf, stdout);
		writen(conn, &recvbuf, 4+n);
	}
}

int main(void)
{
	//创建一个套接字
	int listenfd;
	if((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) //用AF_INET和PF_INET都可以，前两个参数已经可确定是TCP，所以第三个参数可以置0
//	if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) //用AF_INET和PF_INET都可以，前两个参数已经可确定是TCP，所以第三个参数可以置0
		ERR_EXIT("socket_failure");
		//初始化地址
		struct sockaddr_in servaddr;
		memset(&servaddr, 0, sizeof(servaddr));
		servaddr.sin_family = AF_INET;//地址族
		servaddr.sin_port = htons(5188);

		servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//表示本机的任意地址，推荐使用（转换成网络字节序）
		//也可以自己显式指定
//		servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
		//或者
//		inet_aton("127.0.0.1", &servaddr.sin_addr);
		
		//绑定之前开启地址重复利用
		int on = 1;
		if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
			ERR_EXIT("setsockopt_failure");

		//接下来进行绑定,将该套接字与一个本地地址进行绑定
		//需要将IPv4地址结构强制转换为通用地址结构
		if(bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
			ERR_EXIT("bind_failure");//绑定失败
		
		//接下来是监听，将socket从close状态转为监听状态才能够接受连接
		if(listen(listenfd, SOMAXCONN) < 0)
			ERR_EXIT("listen_failure"); 

		//定义一个对方的地址
		struct sockaddr_in peeraddr;
		socklen_t peerlen = sizeof(peeraddr);
		int conn; //一个新的套接字，称为已连接套接字(主动套接字)

		pid_t pid;
		while(1)
		{
			if((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)				
				ERR_EXIT("accept_failure");
			//输出客户端的地址和端口		
			printf("IP=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
			//一旦获得一个连接，就创建一个进程
			pid = fork();
			if(pid == -1)
				ERR_EXIT("fork_failure");
			if(pid == 0)
			{
				//让子进程处理已有的通信过程
				//不再需要监听套接口
				close(listenfd);
				do_service(conn);
				//一旦do_service函数返回，那么该进程就没有存在的价值了
				exit(EXIT_SUCCESS);//此时，为客户端开辟的进程也销毁了
			}
			else
				//父进程进行accept
				//不再需要连接套接口了，即conn（父子进程共享文件描述符）
				close(conn);
				
		}

		//实现一个回射客户/服务器模型
		//即客户端从标准输入获取数据，发送给服务器端，服务器端再回射过去
		
		return 0;
}


客户端：echocli.c 

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

#define ERR_EXIT(m)	\
	do	\
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	}while(0)

struct package{
	int len;
	char buf[1024];
};

ssize_t readn(int fd, void* buf, size_t count)
{
	size_t nleft = count; //剩余要读取的字节数
	ssize_t nread; //每次读取的字节数
	char* bufp = (char*)buf;
	while(nleft > 0)
	{
		if((nread = read(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		if(nread == 0)//对等方关闭
			return count-nleft;
		nleft -= nread;
		bufp += nread;
	}
	return count;
}

ssize_t writen(int fd, void* buf, size_t count)
{
	size_t nleft = count; //剩余要读取的字节数
	ssize_t nwritten; //每次读取的字节数
	char* bufp = (char*)buf;
	while(nleft > 0)
	{
		if((nwritten = write(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		if(nwritten == 0)
			continue;
		nleft -= nwritten;
		bufp += nwritten;
	}
	return count;	
}

int main(void)
{
	int sock;//创建一个套接字
	if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) //用AF_INET和PF_INET都可以，前两个参数已经可确定是TCP，所以第三个参数可以置0
//	if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) //用AF_INET和PF_INET都可以，前两个参数已经可确定是TCP，所以第三个参数可以置0
		ERR_EXIT("socket_failure");
		
		struct sockaddr_in servaddr;
		memset(&servaddr, 0, sizeof(servaddr));
		servaddr.sin_family = AF_INET;//地址族
		servaddr.sin_port = htons(5188);

		//自己显式指定服务器端地址
		servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
		
		//客户端不需要绑定（bind），也不需要监听（listen）
		//直接连接过去就可以
		if(connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
			ERR_EXIT("connect_failure");

		//如果连接成功，就可以进行通信
		struct package sendbuf;
		struct package recvbuf;
		memset(&sendbuf, 0, sizeof(sendbuf));
		memset(&recvbuf, 0, sizeof(recvbuf));
		int n;
		while(fgets(sendbuf.buf, sizeof(sendbuf.buf), stdin) != NULL)
		{
			n = strlen(sendbuf.buf);
			sendbuf.len = htonl(n);
			writen(sock, &sendbuf, 4+n);
			//先读取包头四个字节
			int ret = readn(sock, &recvbuf.len, 4);
			if(ret == -1)
				ERR_EXIT("read error");
			else if(ret == 0)
			{
				printf("peer close\n");
				break;
			}
			//再读取包体,头部长度存储在recvbuf.len中
			n = ntohl(recvbuf.len);
			ret = readn(sock, recvbuf.buf, n);
			if(ret == -1)
				ERR_EXIT("read error");
			else if(ret == 0)
			{
				printf("peerclose\n");
				break;
			}
			//显示出来
			fputs(recvbuf.buf, stdout);
			//这里需要清空缓冲区
			memset(&sendbuf, 0, sizeof(sendbuf));
			memset(&recvbuf, 0, sizeof(recvbuf));			
		}
		//关闭套接口
		close(sock);
		
		return 0;
}
说明：对于写writen，我们发送一个包的总长度为4+n，包括4字节的包头和n字节的包体；

            对于读readn，我们分别读取包头和包体，因为我们在发送的时候，将包体的长度n存放在了结构体的len变量中，因此需要先               读取包头，然后才能够获取包体的长度；


下面介绍另外一种方法解决粘包问题，我们封装一个readline函数，即按行读取消息。

先看代码：

服务器端：ehcosrv.c

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

#define ERR_EXIT(m)	\
	do	\
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	}while(0)


ssize_t readn(int fd, void* buf, size_t count)
{
	//由于不能保证一次能够读取count个字节
	//因此我们需要循环进行读取
	//直到读取的字节数为count
	size_t nleft = count;
	ssize_t nread;
	char* bufp = (char*)buf;
	while(nleft > 0)
	{
		if((nread = read(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)//如果信号中断
				continue;
			return -1;
		}
		if(nread == 0)
			//表示对等方关闭，这里直接返回
			return count-nleft;
		nleft -= nread;//每次读取后剩余的字节数
		bufp += nread;
	}
	return count;
}

ssize_t writen(int fd, void* buf, size_t count)
{
	//我们每次希望写入的字节数为count
	size_t nleft = count;
	ssize_t nwritten;
	char* bufp = (char*)buf;
 	while(nleft > 0)
	{
		if((nwritten = write(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		if(nwritten == 0)
			//什么都没发生
			continue;
		nleft -= nwritten;//每次写后剩余要写的字节数
		bufp += nwritten;
	}
	return count;
}

ssize_t recv_peek(int sockfd, void* buf, size_t len)
{
	//该函数可以从套接口接收数据
	//但是并不将数据从缓冲区中移除
	while(1)
	{
		int ret = recv(sockfd, buf, len, MSG_PEEK);
		//读到数据就返回，否则就返回
		if(ret == -1 && errno == EINTR)
			continue;
		return ret;
	}
}

ssize_t readline(int sockfd, void*buf, size_t maxline)
{
	//读取过程不一定要读取maxline个字节
	//只要遇到\n就可以返回
	int ret;
	int nread;
	char* bufp = buf;
	int nleft = maxline;
	while(1)
	{
		ret = recv_peek(sockfd, bufp, nleft);
		if(ret < 0)
			return ret;
		else if(ret == 0)
			return ret;
		nread = ret;
		int i;
		for(i = 0; i < nread; ++i)
		{
			if(bufp[i] == '\n')
			{
				//我们的recv_peek只是偷窥一下数据
				//并没有一走数据
				//所以这里用readn从缓冲区中移除已偷窥的数据
				ret = readn(sockfd, bufp, i+1);
				if(ret != i+1)
					exit(EXIT_FAILURE);
				return ret;
			}
		}
		//没有遇到\n
		if(nread > nleft)
			exit(EXIT_FAILURE);
		//把读到的数据nread个字节从缓冲区中移走
		nleft -= nread;
		ret = readn(sockfd, bufp, nread);
		if(ret != nread)
			exit(EXIT_FAILURE);
		//继续下一次的偷窥,需偏移
		bufp += nread;
	}
	return -1;
}

void do_service(int conn)
{
	char recvbuf[1024];
	int n;
	while(1)
	{
		memset(&recvbuf, 0, sizeof(recvbuf));
		int ret = readline(conn,  recvbuf, 1024);
		if(ret == -1)
			ERR_EXIT("read failure");
		if(ret == 0)
		{
			printf("client close\n");
			break;
		}
		fputs(recvbuf, stdout);
		writen(conn, recvbuf, strlen(recvbuf));
	}
}

int main(void)
{
	//创建一个套接字
	int listenfd;
	if((listenfd = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) //用AF_INET和PF_INET都可以，前两个参数已经可确定是TCP，所以第三个参数可以置0
//	if((listenfd = socket(AF_INET, SOCK_STREAM, 0)) < 0) //用AF_INET和PF_INET都可以，前两个参数已经可确定是TCP，所以第三个参数可以置0
		ERR_EXIT("socket_failure");
		//初始化地址
		struct sockaddr_in servaddr;
		memset(&servaddr, 0, sizeof(servaddr));
		servaddr.sin_family = AF_INET;//地址族
		servaddr.sin_port = htons(5188);

		servaddr.sin_addr.s_addr = htonl(INADDR_ANY);//表示本机的任意地址，推荐使用（转换成网络字节序）
		//也可以自己显式指定
//		servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
		//或者
//		inet_aton("127.0.0.1", &servaddr.sin_addr);
		
		//绑定之前开启地址重复利用
		int on = 1;
		if(setsockopt(listenfd, SOL_SOCKET, SO_REUSEADDR, &on, sizeof(on)) < 0)
			ERR_EXIT("setsockopt_failure");

		//接下来进行绑定,将该套接字与一个本地地址进行绑定
		//需要将IPv4地址结构强制转换为通用地址结构
		if(bind(listenfd, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
			ERR_EXIT("bind_failure");//绑定失败
		
		//接下来是监听，将socket从close状态转为监听状态才能够接受连接
		if(listen(listenfd, SOMAXCONN) < 0)
			ERR_EXIT("listen_failure"); 

		//定义一个对方的地址
		struct sockaddr_in peeraddr;
		socklen_t peerlen = sizeof(peeraddr);
		int conn; //一个新的套接字，称为已连接套接字(主动套接字)

		pid_t pid;
		while(1)
		{
			if((conn = accept(listenfd, (struct sockaddr*)&peeraddr, &peerlen)) < 0)				
				ERR_EXIT("accept_failure");
			//输出客户端的地址和端口		
			printf("IP=%s port=%d\n", inet_ntoa(peeraddr.sin_addr), ntohs(peeraddr.sin_port));
			//一旦获得一个连接，就创建一个进程
			pid = fork();
			if(pid == -1)
				ERR_EXIT("fork_failure");
			if(pid == 0)
			{
				//让子进程处理已有的通信过程
				//不再需要监听套接口
				close(listenfd);
				do_service(conn);
				//一旦do_service函数返回，那么该进程就没有存在的价值了
				exit(EXIT_SUCCESS);//此时，为客户端开辟的进程也销毁了
			}
			else
				//父进程进行accept
				//不再需要连接套接口了，即conn（父子进程共享文件描述符）
				close(conn);
				
		}

		//实现一个回射客户/服务器模型
		//即客户端从标准输入获取数据，发送给服务器端，服务器端再回射过去
		
		return 0;
}


客户端：echocli.c 

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

#define ERR_EXIT(m)	\
	do	\
	{	\
		perror(m);	\
		exit(EXIT_FAILURE);	\
	}while(0)

ssize_t readn(int fd, void* buf, size_t count)
{
	size_t nleft = count; //剩余要读取的字节数
	ssize_t nread; //每次读取的字节数
	char* bufp = (char*)buf;
	while(nleft > 0)
	{
		if((nread = read(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		if(nread == 0)//对等方关闭
			return count-nleft;
		nleft -= nread;
		bufp += nread;
	}
	return count;
}

ssize_t writen(int fd, void* buf, size_t count)
{
	size_t nleft = count; //剩余要读取的字节数
	ssize_t nwritten; //每次读取的字节数
	char* bufp = (char*)buf;
	while(nleft > 0)
	{
		if((nwritten = write(fd, bufp, nleft)) < 0)
		{
			if(errno == EINTR)
				continue;
			return -1;
		}
		if(nwritten == 0)
			continue;
		nleft -= nwritten;
		bufp += nwritten;
	}
	return count;	
}

ssize_t recv_peek(int sockfd, void* buf, size_t len)
{
	while(1)
	{
		int ret = recv(sockfd, buf, len, MSG_PEEK);
		if(ret == -1 && errno == EINTR)
			continue;
		//偷窥到数据就直接返回
		return ret;
	}
}

ssize_t readline(int sockfd, void*buf, size_t maxline)
{
	char* bufp = buf;
	int nleft = maxline;
	int nread;
	int ret;
	while(1)
	{
		ret = recv_peek(sockfd, bufp, nleft);
		if(ret < 0)
			return ret;
		if(ret == 0)
			return ret;
		nread = ret;
		int i;
		for(i = 0; i < nread; ++i)
		{
			if(bufp[i] == '\n')
			{
				ret = readn(sockfd, bufp, i+1);
				if(ret != i+1)
					exit(EXIT_FAILURE);
				return ret;
			}
		}
		//没有遇到\n
		if(nread > nleft)
			exit(EXIT_FAILURE);
		nleft -= nread;
		ret = readn(sockfd, bufp, nread);
		if(ret != nread)
			exit(EXIT_FAILURE);
		//继续下一次偷窥
		bufp += nread;
	}
	return -1;
}


int main(void)
{
	int sock;//创建一个套接字
	if((sock = socket(AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0) //用AF_INET和PF_INET都可以，前两个参数已经可确定是TCP，所以第三个参数可以置0
//	if((sock = socket(AF_INET, SOCK_STREAM, 0)) < 0) //用AF_INET和PF_INET都可以，前两个参数已经可确定是TCP，所以第三个参数可以置0
		ERR_EXIT("socket_failure");
		
	struct sockaddr_in servaddr;
	memset(&servaddr, 0, sizeof(servaddr));
	servaddr.sin_family = AF_INET;//地址族
	servaddr.sin_port = htons(5188);

	//自己显式指定服务器端地址
	servaddr.sin_addr.s_addr = inet_addr("127.0.0.1");
	
	//客户端不需要绑定（bind），也不需要监听（listen）
	//直接连接过去就可以
	if(connect(sock, (struct sockaddr*)&servaddr, sizeof(servaddr)) < 0)
		ERR_EXIT("connect_failure");

	//连接成功，查看本地的端口和地址
	struct sockaddr_in localaddr;
	socklen_t addrlen = sizeof(localaddr);
	if(getsockname(sock, (struct sockaddr*)&localaddr, &addrlen) < 0)
		ERR_EXIT("getsockname error");
	
	printf("IP=%s port=%d\n", inet_ntoa(localaddr.sin_addr), ntohs(localaddr.sin_port));

	//如果连接成功，就可以进行通信
	char sendbuf[1024] = {0};
	char recvbuf[1024] = {0};
	while(fgets(sendbuf, sizeof(sendbuf), stdin) != NULL)
	{
		writen(sock, sendbuf, strlen(sendbuf));
		//先读取包头四个字节
		int ret = readline(sock, recvbuf, 1024);
		if(ret == -1)
			ERR_EXIT("read error");
		else if(ret == 0)
		{
			printf("peer close\n");
			break;
		}
		//显示出来
		fputs(recvbuf, stdout);
		//这里需要清空缓冲区
		memset(sendbuf, 0, sizeof(sendbuf));
		memset(recvbuf, 0, sizeof(recvbuf));			
	}
	//关闭套接口
	close(sock);
	
	return 0;
}

说明：我们首先利用recv函数封装了一个recv_peek函数，recv函数的特点就是，它仅仅从套接口缓冲区中接收数据到buffer中，但是并不会将数据从该缓冲区中移除，而read函数在读取完数据后会将缓冲区中的数据移除。因此，我们这里就可以先用recv_peek函数先对缓冲区中的内容进行“偷窥”，然后就能知道所“偷窥”内容中有没有分隔符（我们这里是\n），“偷窥”后再利用readn进行读取并将已读取的数据移除缓冲区，这样我们就能够实现数据的按行读取。



發表評論
所有評論
還沒有人評論，想成為第一個評論的人麼? 請在上方評論欄輸入並且點擊發布.
相關文章

TCP Server&Client socket实现（Ubuntu16.04）

TCP Server&Client socket實現（Ubuntu16.04）1 測試：2 TCP Server3 TCP Client 1 測試： 2 TCP Server #include <iostream> #inclu

catkin_ws 2020-07-06 17:33:36

以fork方式实现高性能服务器

前期以socket編程實現TCP Server與Client通信： https://blog.csdn.net/catkin_ws/article/details/107140544 但是會存在問題： 當存在多個客戶端與服務器端通

catkin_ws 2020-07-06 17:33:36

SOCKET端口复用

在WINDOWS的SOCKET服務器應用的編程中，如下的語句或許比比都是：  s=socket(AF_INET,SOCK_STREAM,IPPROTO_TCP); saddr.sin_family = AF_INET;  saddr.

梦幻若水 2020-07-05 02:19:48

18. socket 网络字节序 以及 大端序 小端序

不同CPU中，4字節整數1在內存空間的存儲方式是不同的。4字節整數1可用2進製表示如下： 00000000 00000000 00000000 00000001 有些CPU以上面的順序存儲到內存，另外一些CPU則以倒序存儲，如下

y果子 2020-07-05 00:07:59

SOCKET网络编程——服务器端

3、socket的基本操作 socket()函數 bind()函數 listen()、connect()函數 accept()函數 read()、write()函數 close()函數 if( (socket_fd

halikuiyin 2020-07-01 03:19:45

http编程、socket编程

Http編程： HTTP協議的特點：    支持B/S及C/S模式；    簡單快速：客戶向服務器請求服務時，只需傳送請求方法和路徑。請求方法常用的有GET、HEAD、POST。    靈活：HTTP 允許傳輸任意類型的數據對象。正在傳

cjunl 2020-06-29 04:52:42

反向代理（request.getServerName();）

對於我們通過request.getServerName()方法來獲取服務器的host時，存在以下情況： 正向代理（小泉同學特別愛喫肯德基，可是每次去肯德基店時，發現人好多好多，就算是排一天隊都買不上（無法訪問國外的網站的情形 [奸笑]）。

Felix Chen 2020-06-28 05:34:05

C++socket编程学习总结（1）（建立TCP服务器、并监听）

上次的兩次面試，一位面試官認真的看了我的博客（十分感動），然後建議我好好複習下socket還有操作系統。感覺找工作好多都要求socket編程，於是我再預習複習一下。主要是當時這門課學校老師照本宣科，連代碼都不講，也很沒意思，學生混老師也混

TIM33470348 2020-06-27 11:52:53

学习socket编程--运输层 tcp udp stcp

udp 全稱 user datagram protocol  用戶數據報協議  簡單 不可靠 無連接的協議  UDP 將消息封裝到數據報，再封到IP數據包，然後發送到目的地。 tcp transmission control protoc

阳光下的我们2019 2020-06-23 20:24:21

初学socket编程

做項目經查遇到socket（套接字）的地方，業務的地方大部分直接調用接口，讀取到內容後再返回給接口就ok了，但學習要深究其原理，因此決定學習下socket相關的內容，該文章參考了下面這位大佬的文章，不做搬運工，寫下自己的理解； https

阳光下的我们2019 2020-06-23 20:23:42

【Java基础】网络编程-UDP编程

UDP編程基本概念 TCP/IP協議棧中，TCP協議和UDP協議的聯繫和區別？ 聯繫：TCP和UDP是TCP/IP協議棧中傳輸層的兩個協議，它們使用網絡層功能把數據包發送到目的地，從而爲應用層提供網絡服務。 區別： 1. TCP是

oollXianluo 2020-06-23 02:59:24

【Java基础】网络编程-TCP编程Demo

文章目錄一個客戶端對一個服務端一個服務器對多個客戶端accept()方法一個服務器對多個客戶端的基於控制檯的聊天室小結 一個客戶端對一個服務端 客戶端與服務端一直保持socket連接通過控制檯循環交互 具體表現爲客戶端發起請求,

oollXianluo 2020-06-23 02:59:24

SO_REUSEADDR用法

1、一般來說，一個端口釋放後會等待兩分鐘之後才能再被使用，SO_REUSEADDR是讓端口釋放後立即就可以被再次使用。 SO_REUSEADDR用於對TCP套接字處於TIME_WAIT狀態下的socket，纔可以重複綁定使用。se

慎薇 2020-06-23 01:09:45

java:按行读取服务器压缩文件内容

當前需求是從一臺服務器上的一個目錄讀取所有壓縮文件(文件名是未知的)的內容，從網上搜到的方法都不太完整，以下是本人總結的方法。此處傳進來的路徑只能是最終帶文件名的路徑，不能是目錄。 由於壓縮文件的名稱都是未知的，只能通過

happydream_C 2020-06-25 10:38:38

recv的返回值

在socket通信中，服務端和客戶端連接好了以後就會有發送和接收，那麼怎麼在發送和接收過程知道連接是否正常呢， int recv(   __in          SOCKET s,   __out         char* buf,

wq327 2020-07-01 17:01:23