SOCKET网络编程三：TCP粘包问题处理

最新推荐文章于 2024-06-10 10:01:52 发布
最新推荐文章于 2024-06-10 10:01:52 发布
阅读量428 收藏 3
点赞数
分类专栏： linux网络编程 文章标签： socket tcp粘包
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sinat_22991367/article/details/104299796
版权

TCP是字节流协议，原始数据之间是没有边界的。

发送端为了将多个发往接收端的包，更加高效的的发给接收端，于是采用了优化算法（Nagle算法），将多次间隔较小、数据量较小的数据，合并成一个数据量大的数据块，然后进行封包。

所谓粘包问题本质还是因为接收方不知道消息之间的界限，不知道一次性提取多少字节的数据所造成的。

粘包问题解决方案：

0、发送和接收都定义固定大小。

1、发送方接收方都协商定义数据结构，每次发送后，接收方先解消息头确定，消息内容长度。

2、消息包之间定义明确结束标志，例如\n。

方案1实现：

客户端：

#include<unistd.h>//read/write

#include <sys/types.h>
#include <sys/socket.h>


#include <netinet/in.h>
#include <arpa/inet.h>


#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

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

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

//ssize_t 有符号整数
//size_t 无符号整数	
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;
			}
			else
				return -1;
		}
		else if(nread == 0)//对等方关闭
		{
			count = count - nleft;//已经读取的字节数
			break;
		}
		else
		{
			bufp += nread;
		    nleft -= nread;
		}
	}
	return count;
}

ssize_t writen(int fd,const 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;
			}
			else
				return -1;
		}
		else if(nwritten == 0)//对等方关闭
		{
			continue;
		}
		else
		{
			bufp += nwritten;
		    nleft -= nwritten;
		}
	}
	return count;
}



int main(void)
{
	int sock;//被动套接字
	if(	(sock = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)//创建套接字小于0表示失败
		ERR_EXIT("socket");

	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");//指定服务器端地址

	if(connect(sock,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("connect");


	struct packet sendbuf;
	struct packet recvbuf;

	memset(&recvbuf,0,sizeof(recvbuf));
	memset(&sendbuf,0,sizeof(sendbuf));

	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");
		}
		else if(ret < 4)
		{
			printf("srv_close\n");
			break;
		} 	
		else
		{
			n = ntohl(recvbuf.len);//转换主机字节序
			ret = readn(sock,&recvbuf.buf,n);
			if(ret == -1)
			{
				ERR_EXIT("read");
			}
			else if(ret < n)
			{
				printf("srv_close\n");
				break;
			} 	
			else
			{
				fputs(recvbuf.buf,stdout);//打印
							
				memset(&recvbuf,0,sizeof(recvbuf));
				memset(&sendbuf,0,sizeof(sendbuf));
			}
		}
	}

	close(sock);

	return 0;
}

服务端： 

#include<unistd.h>//read/write

#include <sys/types.h>
#include <sys/socket.h>


#include <netinet/in.h>
#include <arpa/inet.h>


#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

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

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

//ssize_t 有符号整数
//size_t 无符号整数
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;
			}
			else
				return -1;
		}
		else if(nread == 0)//对等方关闭
		{
			count = count - nleft;//已经读取的字节数
			break;
		}
		else
		{
			bufp += nread;
		    nleft -= nread;
		}
	}
	return count;
}
 
ssize_t writen(int fd,const 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;
			}
			else
				return -1;
		}
		else if(nwritten == 0)//对等方关闭
		{
			continue;
		}
		else
		{
			bufp += nwritten;
		    nleft -= nwritten;
		}
	}
	return count;
}

void echo_srv(int conn)
{
	struct packet recvbuf;
	int n;
	while(1)
	{
		memset(&recvbuf,0,sizeof(recvbuf));
		int ret = readn(conn,&recvbuf.len,4);//先取长度,接收包头

		if(ret == -1)
		{
			ERR_EXIT("read");
		}
		else if(ret < 4)
		{
			printf("client_close\n");
			break;
		} 	
		else
		{
			n = ntohl(recvbuf.len);
			ret = readn(conn,&recvbuf.buf,n);
			if(ret == -1)
			{
				ERR_EXIT("read");
			}
			else if(ret < n)
			{
				printf("client_close\n");
				break;
			} 	
			else
			{
				fputs(recvbuf.buf,stdout);//打印
				writen(conn,&recvbuf,4+n);//回射-这里！！
			}
		}
	}
}

int main(void)
{
	/*signal(SIGCHLD,SIG_IGN);*/
	int listenfd;//被动套接字
	if(	(listenfd = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)//创建套接字小于0表示失败
/*	if(	(listenfd = socket(PF_INET,SOCK_STREAM,0))<0);*///让内核自己选定协议
		ERR_EXIT("socket");

	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");

	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("bind");

	if(listen(listenfd,SOMAXCONN)<0)//监听后变为被动套接字
		ERR_EXIT("listen");
	
	struct sockaddr_in peeraddr;
	socklen_t peerlen = sizeof(peeraddr);
	int conn;//主动套接字

//父子进程可以共享文件描述符
	while(1)
	{
		if((conn = accept(listenfd,(struct sockaddr*)&peeraddr,&peerlen))<0)
			ERR_EXIT("accept");

		printf("ip=%s,port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));
		

		int pid = fork();
		if(pid == -1)
			ERR_EXIT("frok");
		if(pid == 0)
		{//子进程不需要处理监听套接字
			close(listenfd);
			echo_srv(conn);
			exit(EXIT_SUCCESS);//如果通信结束(客户端关闭)直接结束进程，否则子进程也会去accept
		}
		else
		{//父进程不需要处理连接套接字
			close(conn);
		}
	}

	return 0;
}

方案2实现：

客户端：

#include<unistd.h>//read/write

#include <sys/types.h>
#include <sys/socket.h>


#include <netinet/in.h>
#include <arpa/inet.h>


#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

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


//ssize_t 有符号整数
//size_t 无符号整数	
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;
			}
			else
				return -1;
		}
		else if(nread == 0)//对等方关闭
		{
			count = count - nleft;//已经读取的字节数
			break;
		}
		else
		{
			bufp += nread;
		    nleft -= nread;
		}
	}
	return count;
}

ssize_t writen(int fd,const 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;
			}
			else
				return -1;
		}
		else if(nwritten == 0)//对等方关闭
		{
			continue;
		}
		else
		{
			bufp += nwritten;
		    nleft -= nwritten;
		}
	}
	return count;
}

//从套接口接收数据，但并不把数据从缓冲区清除
ssize_t recv_peek(int sockfd,void *buf,int len)
{
	while(1)
	{
		int ret = recv(sockfd,buf,len,MSG_PEEK);
		if((ret == -1) && (errno == EINTR))
			continue;

		printf("recv_peek :ret = %d,errno = %d\n",ret,errno);
		return ret;
	}
}


//偷窥方案：
ssize_t readline(int sockfd,void *buf,size_t maxlen)//一行最大的字节数
{//只要遇到/n就返回
	int ret;
	int nread;
	char *bufp = (char *)buf;
	int nleft = maxlen;
	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')//如果找到了结束符就将数据读取出来
			{
				ret = readn(sockfd,bufp,i+1);//下标i，总共有i+1个字符
				if(ret != i+1)
					exit(EXIT_FAILURE);
				return ret;
			}
		}
		//如果没有找到结束符，就读出来先缓存起来
		if(nread > nleft)//ret = recv_peek(sockfd,bufp,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(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)//创建套接字小于0表示失败
		ERR_EXIT("socket");

	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");//指定服务器端地址

	if(connect(sock,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("connect");


	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,sizeof(recvbuf));
		if(ret == -1)
		{
			ERR_EXIT("readline");
		}
		else if(ret == 0)
		{
			printf("client_close\n");
			break;
		} 	
		
		fputs(recvbuf,stdout);//打印
							
		memset(recvbuf,0,sizeof(recvbuf));
		memset(sendbuf,0,sizeof(sendbuf));

	}
	close(sock);

	return 0;
}

服务端：

#include<unistd.h>//read/write

#include <sys/types.h>
#include <sys/socket.h>


#include <netinet/in.h>
#include <arpa/inet.h>


#include <stdlib.h>
#include <stdio.h>
#include <errno.h>
#include <string.h>

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

//ssize_t 有符号整数
//size_t 无符号整数
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;
			}
			else
				return -1;
		}
		else if(nread == 0)//对等方关闭
		{
			count = count - nleft;//已经读取的字节数
			break;
		}
		else
		{
			bufp += nread;
		    nleft -= nread;
		}
	}
	return count;
}
 
ssize_t writen(int fd,const 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;
			}
			else
			{
				return -1;
			}
		}
		else if(nwritten == 0)//对等方关闭
		{
			continue;
		}
		else
		{
			bufp += nwritten;
		    nleft -= 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;
		printf("recv_peek :ret = %d,errno = %d\n",ret,errno);
		return ret;
	}
}


//偷窥方案：
ssize_t readline(int sockfd,void *buf,size_t maxline)//一行最大的字节数
{//只要遇到/n就返回
	int ret;
	int nread;
	char *bufp = (char *)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')//如果找到了结束符就将数据读取出来
			{
				ret = readn(sockfd,bufp,i+1);//下标i，总共有i+1个字符
				if(ret != i+1)
					exit(EXIT_FAILURE);
				return ret;
			}
		}
		//如果没有找到结束符，就读出来先缓存起来
		if(nread > nleft)//ret = recv_peek(sockfd,bufp,nleft);不可能
			exit(EXIT_FAILURE);

		nleft -= nread;//剩余的字节数

		ret = readn(sockfd,bufp,nread);
		if(ret != nread)//偷窥到的数据是可以全部读取出来的
		{
			exit(EXIT_FAILURE);
		}
		bufp += nread;
	}
	return -1;
}

void echo_srv(int conn)
{
	char recvbuf[1024];
	while(1)
	{
		memset(recvbuf,0,sizeof(recvbuf));
		int ret = readline(conn,recvbuf,1024);//按行接收

		if(ret == -1)
		{
			ERR_EXIT("readline");
		}
		if(ret == 0)
		{
			printf("client_close\n");
			break;
		} 	
	
		fputs(recvbuf,stdout);//打印
		writen(conn,recvbuf,strlen(recvbuf));//回射-这里！！
		
	}
}

int main(void)
{
	/*signal(SIGCHLD,SIG_IGN);*/
	int listenfd;//被动套接字
	if(	(listenfd = socket(PF_INET,SOCK_STREAM,IPPROTO_TCP))<0)//创建套接字小于0表示失败
/*	if(	(listenfd = socket(PF_INET,SOCK_STREAM,0))<0);*///让内核自己选定协议
		ERR_EXIT("socket");

	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");

	if(bind(listenfd,(struct sockaddr*)&servaddr,sizeof(servaddr))<0)
		ERR_EXIT("bind");

	if(listen(listenfd,SOMAXCONN)<0)//监听后变为被动套接字
		ERR_EXIT("listen");
	
	struct sockaddr_in peeraddr;
	socklen_t peerlen = sizeof(peeraddr);
	int conn;//主动套接字

//父子进程可以共享文件描述符
	while(1)
	{
		if((conn = accept(listenfd,(struct sockaddr*)&peeraddr,&peerlen))<0)
			ERR_EXIT("accept");

		printf("ip=%s,port=%d\n",inet_ntoa(peeraddr.sin_addr),ntohs(peeraddr.sin_port));
		

		int pid = fork();
		if(pid == -1)
			ERR_EXIT("frok");
		if(pid == 0)
		{//子进程不需要处理监听套接字
			close(listenfd);
			echo_srv(conn);
			exit(EXIT_SUCCESS);//如果通信结束(客户端关闭)直接结束进程，否则子进程也会去accept
		}
		else
		{//父进程不需要处理连接套接字
			close(conn);
		}
	}

	return 0;
}

 

麻子来了
关注
  • 0
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Socket编程 TCP粘包问题及解决方案
my_angle2016的博客
10-21 556
① TCP是个流协议，它存在粘包问题 TCP是一个基于字节流的传输服务，"流"意味着TCP所传输的数据是没有边界的。这不同于UDP提供基于消息的传输服务，其传输的数据是有边界的。TCP的发送方无法保证对等方每次接收到的是一个完整的数据包。主机A向主机B发送两个数据包，主机B的接收情况可能是 产生粘包问题的原因有以下几个： 第一 。应用层调用write方法，将应用层的缓冲区中的数据拷贝到套接字的发送缓冲区。而发送缓冲区有一个SO_SNDBUF的限制，如果应用层的缓冲区数据大小大于套接字发送缓冲区的大
Socket编程（4）TCP粘包问题及解决方案
weixin_34167819的博客
05-28 223
① TCP是个流协议，它存在粘包问题 TCP是一个基于字节流的传输服务，"流"意味着TCP所传输的数据是没有边界的。这不同于UDP提供基于消息的传输服务，其传输的数据是有边界的。TCP的发送方无法保证对等方每次接收到的是一个完整的数据包。主机A向主机B发送两个数据包，主机B的接收情况可能是 产生粘包问题的原因有以下几个： 第一 。应用层调用write方法，将应用层的缓冲区中的数据拷贝到套接字的...
【Socket】解决TCP粘包问题
最新发布
Java程序员的知识博客
06-10 504
TCP一种面向连接的、可靠的、基于字节流的传输层协议。客户端发送服务端连接请求，等待服务端的回复。服务端收到请求，服务端回复客户端，可以建立连接，并等待。客户端收到回复并发送，确认连接。服务端收到回复。连接成功。四次挥手：与三次握手不同，客户端和服务端都可以主动断开连接。服务A向服务B发送FIN报文段，表示没有数据要传输服务B收到报文段，回复一个ACK报文段，表示也没有数据需要传输了。服务B发送FIN报文段，请求关闭连接。
socket编程之解决流协议的粘包问题（一 ）
慎薇的博客
08-11 1360
流协议和粘包这么说吧，TCP在传输数据的时候，是不区分边界的（数据和数据之间没有边界），因为是基于字节流，所以数据对TCP来说就是一大堆没有结构区别的字节块。那意味着什么？意味着TCP并不能对多个数据的整体的信息进行区分（打个比方：就像是你说一堆话没有标点符号全部连在一起，别人很可能弄错）或者对单个整体信息的错误区分（比如你要发送的整块数据被分成了好几块发送，然后这些数据在传输过程中可能由于网络原因
8-10-异常处理、套接字socket
peek-a-boom
08-10 312
本周内容： day01 01 异常处理 02 socket编程 网络基础：OSI七层协议 day02 01 网络基础 02 socket编程 基于tcp协议的套接字编程 day03 01 粘包问题 02 基于udp协议的套接字通信 day04 01 sockserver编写支持并发的套接字 day05
深入理解socket中的recv函数和send函数
热门推荐
Janway-Win
08-03 1万+
一、函数原型 **·**recv函数用于socket通信中接收消息，接口定义如下： ssize_t recv(int socket, void *buf, size_t len, int flags) 参数一：指定接收端套接字描述符； 参数二：指向一个缓冲区，该缓冲区用来存放recv函数接收到的数据； 参数三：指明buf的长度； 参数四：一般置为0； 返回值：失败时，返回值小于0；超时或对端主动关闭，返回值等于0；成功时，返回值是返回接收数据的长度。 **·**send函数用于socket通信中发送消息，
C#中TCP粘包问题的解决方法
08-30
在TCP/IP通信中，"粘包"问题是一个常见的现象，...总的来说，处理TCP粘包问题需要理解TCP的工作原理，并结合适当的策略来确保数据的正确传输和处理。在实际应用中，通常需要结合具体需求和场景来选择最合适的解决方案。
python socket网络编程之粘包问题详解
12-24
一，粘包问题详情 1，只有TCP有粘包现象，UDP永远不会粘包 你的程序实际上无权直接操作网卡的，你操作网卡都是通过操作系统给用户程序暴露出来的接口，那每次你的程序要给远程发数据时，其实是先把数据从用户态...
Socket编程TCP粘包Demo.zip
05-22
本示例通过"Socket编程TCP粘包Demo.zip"提供了客户端和服务器端的代码，帮助我们更直观地理解这一现象。 首先，TCP粘包是指在接收方收到的数据边界不清晰，多个小的数据包被合并成一个大的数据包进行接收的情况。这...
C#TCP\Socket粘包处理(加长度头)
04-11
1. **理解TCP粘包** - TCP是一个字节流服务，没有天然的数据包边界。 - 粘包是由于TCP的流量控制和拥塞控制可能导致的数据交错。 - 数据可能会在发送端被缓冲，然后一次性发送出去，或者在接收端被合并。 2. **...
【QT】自定义协议解决TCP粘包和拆包问题
08-11
总结来说，QT提供的网络编程接口和C++的数据流操作为我们提供了一种有效解决TCP粘包和拆包问题的途径。通过自定义协议，结合序列化和反序列化技术，我们可以在TCP通信中实现可靠的数据交换，确保应用的正常运行。在...
luasocket lua第三方网络库
05-24
luasocket lua第三方网络库
解决 Socket 网络通讯中的粘包、半包问题
weixin_44262126的博客
05-02 985
1）本文章针对 Java 以及 Python 两种语言的不同特性来解决 Socket 网络通讯中的粘包、半包问题，这两种解决办法的代码实现自己思考了很久，所以讨个赞不过分吧。 1 什么是半包、粘包问题 TCP通讯为何存在粘包呢？主要原因是 TCP 是以流的方式来处理数据，再加上网络上 MTU 的往往小于在应用处理的消息数据，所以就会引发一次接收的数据无法满足消息的需要，导致粘包的存在。 处理粘包的唯一方法就是制定应用层的数据通讯协议，通过协议来规范现有接收的数据是否满足消息数据的需要。   2.
#define+do{} while（0）+peeror的思考
L未若的博客
02-24 2058
今天看到这样一个程序，#define ERR_EXIT(m) do { perror(m); exit(EXIT_FAILURE);} while(0) 1.    #define 与do{}while（）函数的特殊结合 2.    perror函数 3.    exit函数以及EXIT_TAIURE 关于宏中使用do-while函数 1.一般我们都知道
luasock
yangzhenzhen的专栏
03-20 1019
 http://w3.impa.br/~diego/software/luasocket/http.html
recv()函数中MSG_PEEK参数的解释
sinat_37372543的博客
09-01 4052
通常recv()函数的最后一个参数为0，代表从缓冲区取走数据，而当为MSG_PEEK时代表只是查看数据，而不取走数据。 举例：例如套接字缓冲区现有序列''abc'',外部缓冲区即字符数组大小为1，每次只能从套接字中缓冲区读取一个字符。当最后一个参数为0时，调用recv()，套接字缓冲区序列变为''bc''。当最后一个参数为MSG_PEEK时，调用recv(),套接字缓冲区为''abc''。 ...
MSG_PEEK
fysy0000的专栏
08-10 8350
因为UDP是按数据包接收的，我们在接收之前并不知道这个数据包有多大。一个策略是，我们准备足够大的应用程序缓存以免出错，但是这个“足够大”的概念是建立在我们对传送的数据事先有了解的情况下，比如是我们自己设计服务器端和客户端并且制定应用层协议；另外一种策略是，将一个数据包的相关信息记
socket成员方法
sunnet的专栏
05-04 856
这些方法被分成了几组。并不是所有的方法都可以在各个类型的套接字里使用。这个部分的结尾将有一个 列表来展示各个方法分别属于哪个socket类。 注意所有的异步方法都立刻返回，而它们相对的同步实现需要操作完成之后才能返回 1. 连接相关的函数 这些方法是用来连接或绑定socket、断开socket字连接以及查询连接是活动还是非活动的： assign(protocol,socket)：
Linux多线程网络编程：muduo库实战指南
书中的问题和挑战反映了网络编程实践中常见的困扰，比如数据完整性问题、TCP粘包问题、消息帧设计、带外数据（OOB）和信号驱动IO的使用场景，以及网络消息格式的设计和跨平台通信等。通过解答这些问题，本书不仅教授...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值