TCP 粘包问题及解决方案

时间  2019-11-06 标签 tcp 问题 解决 方案

1、TCP粘包问题

TCP是一个基于字节流的传输服务，"流"意味着TCP所传输的数据是没有边界的。这不一样于UDP提供基于消息的传输服务，其传输的数据是有边界的。TCP的发送方没法保证对等方每次接收到的是一个完整的数据包。主机A向主机B发送两个数据包，主机B的接收状况多是以下几种状况：算法

产生粘包问题的缘由有如下几个：网络

一、应用层调用write方法，将应用层的缓冲区中的数据拷贝到套接字的发送缓冲区。而发送缓冲区有一个SO_SNDBUF的限制，若是应用层的缓冲区数据大小大于套接字发送缓冲区的大小，则数据须要进行屡次的发送。
二、TCP所传输的报文段有MSS的限制，若是套接字缓冲区的大小大于MSS，也会致使消息的分割发送。
三、因为链路层最大发送单元MTU，在IP层会进行数据的分片。
这些状况都会致使一个完整的应用层数据被分割成屡次发送，致使接收对等方不是按完整数据包的方式来接收数据。socket

四、发送端须要等缓冲区满才发送出去，形成粘包（由Nagle算法形成的发送端的粘包）
五、接收方不及时接收缓冲区的包，形成多个包接收（接收端接收不及时形成的接收端粘包）函数

2、粘包的问题的解决

粘包问题的最本质缘由在与接收对等方没法分辨消息与消息之间的边界在哪。咱们经过使用某种方案给出边界，例如：spa

一、发送定长包。若是每一个消息的大小都是同样的，那么在接收对等方只要累计接收数据，直到数据等于一个定长的数值就将它做为一个消息。这里须要封装两个函数：指针

ssize_t readn(int fd, void *buf, size_t count)
ssize_t writen(int fd, void *buf, size_t count)

这两个函数的参数列表和返回值与read、write一致，做用是读取/写入count个字节后再返回。实现以下：code

ssize_t readn(int fd, void *buf, size_t count)
{
        int left = count ; //剩下的字节
        char * ptr = (char*)buf ;
        while(left>0)
        {
                int readBytes = read(fd,ptr,left);
                if(readBytes< 0)//read函数小于0有两种状况：1中断 2出错
                {
                        if(errno == EINTR)//读被中断
                        {
                                continue;
                        }
                        return -1;
                }
                if(readBytes == 0)//读到了EOF
                {
                        //对方关闭呀
                        printf("peer close\n");
                        return count - left;
                }
                left -= readBytes;
                ptr += readBytes ;
        }
        return count ;
}

/*
writen 函数
写入count字节的数据
*/
ssize_t writen(int fd, void *buf, size_t count)
{
        int left = count ;
        char * ptr = (char *)buf;
        while(left >0)
        {
                int writeBytes = write(fd,ptr,left);
                if(writeBytes<0)
                {
                        if(errno == EINTR)
                                continue;
                        return -1;
                }
                else if(writeBytes == 0)
                        continue;
                left -= writeBytes;
                ptr += writeBytes;
        }
        return count;
}

有了这两个函数以后，咱们就可使用定长包来发送数据了，我抽取其关键代码来说述：接口

char readbuf[512];
readn(conn,readbuf,sizeof(readbuf));  //每次读取512个字节

同理的，写入的时候也写入512个字节：get

char writebuf[512];
fgets(writebuf,sizeof(writebuf),stdin);
writen(conn,writebuf,sizeof(writebuf);

每一个消息都以固定的512字节（或其余数字，看你的应用层的缓冲区大小）来发送，以此区分每个信息，这即是以固定长度解决粘包问题的思路。定长包解决方案的缺点在于会致使增长网络的负担，不管每次发送的有效数据是多大，都得按照定长的数据长度进行发送。it


二、包尾加上\r\n标记。FTP协议正是这么作的。但问题在于若是数据正文中也含有\r\n，则会误判为消息的边界。咱们在这里实现一个按行读取的功能，该功能可以按/n来识别消息的边界。这里介绍一个函数：

ssize_t recv(int sockfd, void *buf, size_t len, int flags);

与read函数相比，recv函数的区别在于两点：

  1. recv函数只能够用于套接口IO。
  2. recv函数含有flags参数，能够指定一些选项。

recv函数的flags参数经常使用的选项是：

  1. MSG_OOB 接收带外数据，即经过紧急指针发送的数据
  2. MSG_PEEK 从缓冲区中读取数据，但并不从缓冲区中清除所读数据

为了实现按行读取，咱们须要使用recv函数的MSG_PEEK选项。PEEK的意思是"偷看"，咱们能够理解为窥视，看看socket的缓冲区内是否有某种内容，而清除缓冲区。

/*
* 封装了recv函数
  返回值说明：-1 读取出错 
*/
ssize_t read_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;
        }
}

下面是按行读取的代码：

/*
*读取一行内容
* 返回值说明：
        == 0 ：对端关闭
        == -1 ： 读取错误
        其余：一行的字节数，包含\n
* 
**/
ssize_t readLine(int sockfd ,void * buf ,size_t maxline)
{
        int ret ;
        int nRead = 0;
        int left = maxline ;
        char * pbuf  = (char *) buf;
        int count  = 0;
        while(true)
        {
                //从socket缓冲区中读取指定长度的内容，但并不删除
                ret = read_peek(sockfd,pbuf,left);
                // ret = recv(sockfd , pbuf , left , MSG_PEEK);
                if(ret<= 0)
                        return ret;
               nRead = ret ;
                for(int i = 0 ;i< nRead ; ++i)
                {
                        if(pbuf[i]=='\n') //探测到有\n
                        {
                                ret = readn (sockfd , pbuf, i+1);
                                if(ret != i+1)
                                        exit(EXIT_FAILURE);
                                return ret + returnCount;
                        }
                }
                //若是嗅探到没有\n
                //那么先将这一段没有\n的读取出来
                ret  = readn(sockfd , pbuf , nRead);
                if(ret != nRead)
                        exit(EXIT_FAILURE);
                pbuf += nRead ;
                left -= nRead ;
                count += nRead;
        }
        return -1;
}

 

三、包头加上包体长度。包头是定长的4个字节，说明了包体的长度。接收对等方先接收包体长度，依据包体长度来接收包体。

struct packet
{
        unsigned int msgLen ;  //4个字节字段，说明数据部分的大小
        char data[512] ;  //数据部分 
}

读写过程以下所示，这里抽取关键代码进行说明：

//发送数据过程
struct packet writebuf;
memset(&writebuf,0,sizeof(writebuf));
while(fgets(writebuf.data,sizeof(writebuf.data),stdin)!=NULL)
{      
     int n = strlen(writebuf.data);   //计算要发送的数据的字节数
     writebuf.msgLen =htonl(n);    //将该字节数保存在msgLen字段，注意字节序的转换
     writen(conn,&writebuf,4+n);   //发送数据，数据长度为4个字节的msgLen 加上data长度
     memset(&writebuf,0,sizeof(writebuf)); 
}

下面是读取数据的过程，先读取msgLen字段，该字段指示了有效数据data的长度。依据该字段再读出data。

memset(&readbuf,0,sizeof(readbuf));
int ret = readn(conn,&readbuf.msgLen,4); //先读取四个字节，肯定后续数据的长度
if(ret == -1)
{      
   err_exit("readn");
}
else if(ret == 0)
{
   printf("peer close\n");
   break;
}
int dataBytes = ntohl(readbuf.msgLen); //字节序的转换
int readBytes = readn(conn,readbuf.data,dataBytes); //读取出后续的数据
if(readBytes == 0)
{
   printf("peer close\n");
   break;
}
if(readBytes<0)
{
   err_exit("read");
}

 

四、使用更加复杂的应用层协议。

联系我们 沪ICP备13005482号-10