TCP的粘包和拆包问题及解决

前言

TCP属于传输层的协议，传输层除了有TCP协议外还有UDP协议。那么UDP是否会发生粘包或拆包的现象呢？答案是不会。UDP是基于报文发送的，从UDP的帧结构可以看出，在UDP首部采用了16bit来指示UDP数据报文的长度，因此在应用层能很好的将不同的数据报文区分开，从而避免粘包和拆包的问题。而TCP是基于字节流的，虽然应用层和TCP传输层之间的数据交互是大小不等的数据块，但是TCP把这些数据块仅仅看成一连串无结构的字节流，没有边界；另外从TCP的帧结构也可以看出，在TCP的首部没有表示数据长度的字段，基于上面两点，在使用TCP传输数据时，才有粘包或者拆包现象发生的可能。

解决TCP粘包和拆包得方法

• 发送端给每个数据包添加包首部，首部中应该至少包含数据包的长度，这样接收端在接收到数据后，通过读取包首部的长度字段，便知道每一个数据包的实际长度了。
• 发送端将每个数据包封装为固定长度（不够的可以通过补0填充），这样接收端每次从接收缓冲区中读取固定长度的数据就自然而然的把每个数据包拆分开来。
• 可以在数据包之间设置边界，如添加特殊符号，这样，接收端通过这个边界就可以将不同的数据包拆分开。
  
  等等。

封装一个带首部信息得包

一个网络数据包包括：首部大小(size_t)，操作类型(int)+数据(char*)。

假设有定义的结构体CMD_TYPE_T是用来标识操作类型

typedef enum cmd_Type
{
    Cmd_LoginRequest = 1,
    Cmd_LoginResponse = 2,
} CMD_TYPE_T;

C语言

头文件tcpwrap.h

#ifndef TCPWRAP_H
#define TCPWRAP_H

#include <memory>
#include <netinet/in.h>
#include <string.h>

//指定字节对齐
#pragma pack(push,1)

typedef struct
{
    size_t length;
    int cmd;
}Packet;

#pragma pack(pop)

class TcpDataWrap
{
public:
	TcpDataWrap();
public:
	void sendPackData(int sockfd, CMD_TYPE_T cmd, char* buf, int bufLen);
	size_t recvUnpackData (int sockfd ,char*& recvBuf);
};

#endif

源文件tcpwrap.cpp

#include "tcpwrap.h"

TcpDataWrap::TcpDataWrap() {}

//对数据进行封包，然后发送
void TcpDataWrap::sendPackData(int sockfd, CMD_TYPE_T cmd, char* buf, int bufLen)
{
	Packet pack;
	size_t headSize = sizeof(pack.length);
	size_t cmdSize = sizeof(pack.cmd);
	size_t totalLen = headSize + cmdSize + bufLen;

	pack.length = totalLen - headSize;
	pack.cmd = cmd;
	char* sendBuf = new char[totalLen];
	memset(sendBuf,0,totalLen);
	memcpy(sendBuf, &pack.length, headSize);
	memcpy(sendBuf + headSize, &pack.cmd, cmdSize);
	memcpy(sendBuf + headSize + cmdSize, buf, bufLen);

	send(sockfd, sendBuf, totalLen,0);	//发送数据
	delete[] sendBuf;
}

//收到得数据存储在recvbuf中，并返回recvBuf的大小
size_t TcpDataWrap::recvUnpackData (int sockfd ,char*& recvBuf)
{
	size_t byteRead=0;
	size_t headSize = 0;
	while (byteRead <sizeof(size_t))
	{
		byteRead = recv(sockfd, &headSize, sizeof(size_t), MSG_PEEK);	//查看数据长度是否满足包头的大小要求
	}
	recv(sockfd, &headSize, sizeof(size_t), 0);

	recvBuf = new char[headSize];
	char* pData = recvBuf;

	size_t byteLeft = headSize;

	while (byteLeft>0)
	{
		byteRead = recv(sockfd, pData, byteLeft, 0);
		byteLeft -= byteRead;
		pData += byteRead;
	}
	return headSize;
}

Qt版

头文件tcpwrap.h

#ifndef TCPWRAP_H
#define TCPWRAP_H

#include <memory>
#include <string.h>
#include <QTcpSocket>

//字节对齐
#pragma pack(push,1)

typedef struct
{
    size_t length;
    int cmd;
}Packet;

#pragma pack(pop)

class TcpDataWrap : public QObject
{
public:
    TcpDataWrap();
public:
    void sendPackData(QTcpSocket* sockfd, CMD_TYPE_T cmd, char* buf, size_t bufLen);
    size_t recvUnpackData (QTcpSocket* sockfd, char*& buf);
};

#endif // TCPWRAP_H

#include "tcpwrap.h"
#include <QTcpSocket>

TcpDataWrap::TcpDataWrap(){}

//对数据进行封包，然后发送
void TcpDataWrap::sendPackData(QTcpSocket* sockfd, CMD_TYPE_T cmd, char* buf, size_t bufLen)
{
    Packet pack;
    size_t headSize = sizeof (pack.length); //头为8字节
    size_t cmdSize = sizeof(pack.cmd);  //操作位4字节
    size_t totalLen = headSize + cmdSize + bufLen;
    pack.length = totalLen - headSize;
    pack.cmd = cmd;

    char* sendBuf = new char[totalLen];  //要发送的缓冲区
    memset(sendBuf,0,totalLen);
    memcpy(sendBuf,&pack.length,headSize);
    memcpy(sendBuf+headSize,&pack.cmd,cmdSize);
    memcpy(sendBuf+headSize+cmdSize, buf, bufLen);
    sockfd->write(sendBuf,totalLen);
    delete [] sendBuf;
}

size_t TcpDataWrap::recvUnpackData (QTcpSocket* sockfd, char*& recvBuf)
{
    size_t byteRead = 0;
    size_t headSize = 0;
    while (byteRead<sizeof (size_t))
    {
        byteRead=sockfd->bytesAvailable();
    }
    sockfd->read((char*)&headSize,sizeof (size_t));
    recvBuf = new char[headSize];
    char* pData = recvBuf;
    size_t byteLeft = headSize;
    while (byteLeft>0)
    {
        byteRead=sockfd->read(pData,byteLeft);
        byteLeft -= byteRead;
        pData += byteRead;
    }
    return  headSize;
}