TCP的粘包问题

最新推荐文章于 2025-03-05 10:26:05 发布

zhanglei_1991

最新推荐文章于 2025-03-05 10:26:05 发布

阅读量1.1k

点赞数 1

本文链接：https://blog.youkuaiyun.com/zhang2531/article/details/52618804

版权

最近面试的时候被问到了Socket编程时怎么处理“粘包”问题，当时愣了一下，什么是粘包。。。。。后来面试官耐心的给我解释了下，才明白。当时只想起来在做分拣系统项目的确实出现过，接收到的数据长度不对的问题。当时不明白原理，为啥会出现这种问题，只是尝试了减小客户端发送的频次，在服务器端加上了16位的CRC校验，长度不对，数据不对的包就直接丢掉，然后问题就解决了。面试结束后，找了很多关于粘包的资料和解决方案，才知道当时也是幸运才把这个问题解决掉的，只靠那几种措施在多数情况下没办法处理这个问题。

首先分拣系统监控软件这个项目当时制定的通信协议是客户端固定发送40个十六进制的字符，正是因为发送方和接收方知道每次发送接收的长度，所以粘包的问题就很好解决了。其次因为客户端发送的消息频率足够，而且系统对实时性要求不高，所以偶尔丢掉一个错误的包是没关系的。另外为了解决个别出现的长度虽然对，但是依然出错的包，特意加上了CRC循环冗余校验。虽然数据链路层已经做过了，但是这两个校验意义不一样，链路层的校验是为了保证数据帧的正确传输，而系统软件的冗余校验是为了解决经过TCP协议处理后的粘包，错包问题，不知道这样理解对不对，哈哈。这个项目的问题当时就这么轻而易举的解决了，但是很多情况下这些措施不适合，下面列举了一些自己查找的关于粘包，错包，少包的一些解决方案和资料，做了些简单的补充了修改，原文地址贴在文章末尾：

TCP（transport control protocol，传输控制协议）是面向连接的，面向流的，提供高可靠性服务。收发两端（客户端和服务器端）都要有一一成对的socket，因此，发送端为了将多个发往接收端的包，更有效的发到对方，使用了优化方法（Nagle算法），将多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包。这样，接收端，就难于分辨出来了，必须提供科学的拆包机制。 即面向流的通信是无消息保护边界的。

UDP（user datagram protocol，用户数据报协议）是无连接的，面向消息的，提供高效率服务。不会使用块的合并优化算法，, 由于UDP支持的是一对多的模式，所以接收端的skbuff(套接字缓冲区）采用了链式结构来记录每一个到达的UDP包，在每个UDP包中就有了消息头（消息来源地址，端口等信息），这样，对于接收端来说，就容易进行区分处理了。 即面向消息的通信是有消息保护边界的。

由于TCP无消息保护边界, 需要在消息接收端处理消息边界问题。也就是为什么我们以前使用UDP没有此问题。反而使用TCP后，出现少包的现象。

粘包的分析

上面说了原理，但可能有人使用TCP通信会出现多包/少包，而一些人不会。那么我们具体分析一下，少包，多包的情况。

正常情况，发送及时每消息发送，接收也不繁忙，及时处理掉消息。像UDP一样.
发送粘包,多次间隔较小且数据量小的数据，合并成一个大的数据块，然后进行封包. 这种情况和客户端处理繁忙，接收缓存区积压，用户一次从接收缓存区多个数据包的接收端处理一样。
发送粘包或接收缓存区积压，但用户缓冲区大于接收缓存区数据包总大小。此时需要考虑处理一次处理多数据包的情况，但每个数据包都是完整的。
发送粘包或接收缓存区积压，用户缓存区是数据包大小的整数倍。此时需要考虑处理一次处理多数据包的情况，但每个数据包都是完整的。
发送粘包或接收缓存区积压，用户缓存区不是数据包大小的整数倍。此时需要考虑处理一次处理多数据包的情况，同时也需要考虑数据包不完整。

我们的情况就属于最后一种，发生了数据包不完整的情况。

啰嗦了这么多，总结一下，就两种情况下会发生粘包。

发送端需要等缓冲区满才发送出去，造成粘包
接收方不及时接收缓冲区的包，造成多个包接收

如何应对

先卖个关子，不是所有的粘包都需要处理。我们先列举一下，免得在编码过程中，因为知道了粘包的情况下，都处理粘包。

连续的数据流不需要处理。如一个在线视频，它是一个连续不断的流，不需要考虑分包。
每发一个消息，建一次连接的情况。
发送端使用了TCP强制数据立即传送的操作指令push。
UDP, 前面已说明白了。在这在强调一下，UDP不需要处理，免的忘记了。

把官网上的代码，也在这展示一下。

public class ImageResponseDecoder extends CumulativeProtocolDecoder {

/**
* 返回值的解释：
* 1、false, 继续接收下一批数据，有两种情形，如缓冲区数据刚刚就是一个完整消息，或不够一条消息时。如果不够一条消息，那么会将下一批数据和剩余消息进行合并
* 2、true, 当缓冲区的消息多于一条消息时，剩余消息会再会推送至doDecode
*/

protected boolean doDecode(IoSession session, IoBuffer in, ProtocolDecoderOutput out)throws Exception {
//发送数据时，头四个字节记录了消息的长度。此方法会读四个字节，并和实现流长度对比。返回前，将流reset.
if (in.prefixedDataAvailable(4)) {
int length = in.getInt();
byte [] bytes = newbyte[length];
in.get(bytes);
ByteArrayInputStream bais =new ByteArrayInputStream(bytes);
BufferedImage image = ImageIO.read(bais);
out.write(image);
return true;//如果读取内容后还粘了包，系统会自动处理。
}else{
returnfalse;//继续接收数据，以待数据完整
}
}
}

<p><span style="color: rgb(153, 255, 153);">    </span></p>

再总结一下处理流程: 就发送数据时，包开始写入消息长度n，当接收到的缓存区数据m，各处理流程如下：
1)若n<m，则表明数据流包含多包数据，从其头部截取n个字节存入临时缓冲区，剩余部分数据依此继续循环处理，直至结束。或n>m
2)若n=m，则表明数据流内容恰好是一完整结构数据，直接将其存入临时缓冲区即可。
3)若n >m，则表明数据流内容尚不够构成一完整结构数据，需留待与下一包数据合并后再行处理。

TCP通讯处理粘包详解

一般所谓的TCP粘包是在一次接收数据不能完全地体现一个完整的消息数据。TCP通讯为何存在粘包呢？主要原因是TCP是以流的方式来处理数据，再加上网络上MTU的往往小于在应用处理的消息数据，所以就会引发一次接收的数据无法满足消息的需要，导致粘包的存在。处理粘包的唯一方法就是制定应用层的数据通讯协议，通过协议来规范现有接收的数据是否满足消息数据的需要。在应用中处理粘包的基础方法主要有两种分别是以4节字描述消息大小或以结束符，实际上也有两者相结合的如HTTP,redis的通讯协议等。

在平时交流过程发现一些朋友即使做了这些协议的处理，但有时在处理数据的时候也会出现数据不对的情况。这主要原因他们在一些个别情况下没有处理好。因为当一系列的消息发送过来的时候，对于4节字头或结束符分布位置都是不确定的。一种简单的情况就是当前消息处理完成后，紧接着就是处理一下个消息的4节字描述，但在实际情况下当前接收的buffer剩下的内容有可能不足4节字的。如果你想通过通讯的程序来测这情况相对来说触发的机率性不高，所以对于协议分析的功能最好通过单元测试来模拟。

下面简单地介绍一下4字节描述大小和结束符和处理方式。

4字节大小描述方式

 1         public void Import(byte[] data, int start, int count)
 2         {
 3             while (count > 0)
 4             {
 5                 if (!mLoading)
 6                 {
 7                     mCheckSize.Reset();
 8                     mStream.SetLength(0);
 9                     mStream.Position = 0;
10                     mLoading = true;
11                 }
12                 if (mCheckSize.Length == -1)
13                 {
14                     while (count > 0 && mCheckSize.Length == -1)
15                     {
16                         mCheckSize.Import(data[start]);
17                         start++;
18                         count--;
19                     }
20                 }
21                 else
22                 {
23                     if (OnImport(data, ref start, ref count))
24                     {
25                         mLoading = false;
26                         if (Receive != null)
27                         {
28                             mStream.Position = 0;
29                             Receive(mStream);
30                         }
31                     }
32                 }
33             }
34         }
35 
36 
37         public void Import(byte value)
38         {
39             LengthData[mIndex] = value;
40             if (mIndex == 3)
41             {
42                 Length = BitConverter.ToInt32(LengthData, 0);
43                 if (!LittleEndian)
44                     Length = Endian.SwapInt32(Length);
45             }
46             else
47             {
48                 mIndex++;
49             }
50         }

代码很简单如果没有长度描述的情况就把数据导入到消息长度描述的buffer中，如果当前buffer满足4位的情况直接得到相应长度。后面的工作就是获取相应长度的buffer即可。

结束符方式

 1         public void Import(byte[] data, int start, int count)
 2         {
 3             while (count > 0)
 4             {
 5                 if (!mLoading)
 6                 {
 7                     mStream.SetLength(0);
 8                     mStream.Position = 0;
 9                     mLoading = true;
10                 }
11                 if (data[x] == mEof[0])
12                 {
13                     start += mEof.Length;
14                     count -= mEof.Length;
15                     mLoading = false;
16                     if (Receive != null)
17                     {
18                         mStream.Position = 0;
19                         Receive(mStream);
20                     }
21                 }
22                 else
23                 {
24                     mStream.Write(data[start]);
25                     start++;
26                     count--;
27                 }
28             }
29         }

结束符的处理方式就相对来说简单多了。

以上就是两种TCP数据处理粘包的情况，相关代码紧供参考。

关于TCP封包、粘包、半包

关于Tcp封包

TCP大致工作原理介绍：

工作原理

TCP-IP详解卷1第17章中17.2节对TCP服务原理作了一个简明介绍(以下蓝色字体摘自《TCP-IP详解卷1第17章17.2节》)：

尽管T C P和U D P都使用相同的网络层（ I P），T C P却向应用层提供与U D P完全不同的服务。T C P提供一种面向连接的、可靠的字节流服务。面向连接意味着两个使用T C P的应用（通常是一个客户和一个服务器）在彼此交换数据之前必须先建立一个T C P连接。这一过程与打电话很相似，先拨号振铃，等待对方摘机说“喂”，然后才说明是谁。在第1 8章我们将看到一个T C P连接是如何建立的，以及当一方通信结束后如何断开连接。

在一个T C P连接中，仅有两方进行彼此通信。在第1 2章介绍的广播和多播不能用于T C P。

T C P通过下列方式来提供可靠性：

• 应用数据被分割成T C P认为最适合发送的数据块。这和U D P完全不同，应用程序产生的数据报长度将保持不变。由T C P传递给I P的信息单位称为报文段或段（ s e g m e n t）（参见图1 - 7）。在1 8 . 4节我们将看到T C P如何确定报文段的长度。

• 当T C P发出一个段后，它启动一个定时器，等待目的端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段。在第2 1章我们将了解T C P协议中自适应的超时及重传策略。

• 当T C P收到发自T C P连接另一端的数据，它将发送一个确认。这个确认不是立即发送，通常将推迟几分之一秒，这将在1 9 . 3节讨论。

• T C P将保持它首部和数据的检验和。这是一个端到端的检验和，目的是检测数据在传输过程中的任何变化。如果收到段的检验和有差错， T C P将丢弃这个报文段和不确认收到此报文段（希望发端超时并重发）。

• 既然T C P报文段作为I P数据报来传输，而I P数据报的到达可能会失序，因此T C P报文段的到达也可能会失序。如果必要， T C P将对收到的数据进行重新排序，将收到的数据以正确的顺序交给应用层。

• 既然I P数据报会发生重复， T C P的接收端必须丢弃重复的数据。

• T C P还能提供流量控制。T C P连接的每一方都有固定大小的缓冲空间。T C P的接收端只允许另一端发送接收端缓冲区所能接纳的数据。这将防止较快主机致使较慢主机的缓冲区溢出。两个应用程序通过T C P连接交换8 bit字节构成的字节流。T C P不在字节流中插入记录标识符。我们将这称为字节流服务（ byte stream service）。如果一方的应用程序先传1 0字节，又传2 0字节，再传5 0字节，连接的另一方将无法了解发方每次发送了多少字节。收方可以分4次接收这8 0个字节，每次接收2 0字节。一端将字节流放到T C P连接上，同样的字节流将出现在T C P连接的另一端。另外，T C P对字节流的内容不作任何解释。T C P不知道传输的数据字节流是二进制数据，还是A S C I I字符、E B C D I C字符或者其他类型数据。对字节流的解释由T C P连接双方的应用层解释。这种对字节流的处理方式与U n i x操作系统对文件的处理方式很相似。U n i x的内核对一个应用读或写的内容不作任何解释，而是交给应用程序处理。对U n i x的内核来说，它无法区分一个二进制文件与一个文本文件。

T C P如何确定报文段的长度

我仍然引用官方解释《TCP-IP详解卷1》第18章18.4节：

最大报文段长度（ M S S）表示T C P传往另一端的最大块数据的长度。当一个连接建立时【三次握手】，连接的双方都要通告各自的M S S。我们已经见过M S S都是1 0 2 4。这导致I P数据报通常是4 0字节长：2 0字节的T C P首部和2 0字节的I P首部。

在有些书中，将它看作可“协商”选项。它并不是任何条件下都可协商。当建立一个连接时，每一方都有用于通告它期望接收的M S S选项（M S S选项只能出现在S Y N报文段中）。如果一方不接收来自另一方的M S S值，则M S S就定为默认值5 3 6字节（这个默认值允许2 0字节的I P首部和2 0字节的T C P首部以适合5 7 6字节I P数据报)。

一般说来，如果没有分段发生， M S S还是越大越好（这也并不总是正确，参见图2 4 - 3和图2 4 - 4中的例子）。报文段越大允许每个报文段传送的数据就越多，相对I P和T C P首部有更高的网络利用率。当T C P发送一个S Y N时，或者是因为一个本地应用进程想发起一个连接，或者是因为另一端的主机收到了一个连接请求，它能将M S S值设置为外出接口上的M T U长度减去固定的I P首部和T C P首部长度。对于一个以太网， M S S值可达1 4 6 0字节。使用IEEE 802.3的封装（参见2 . 2节），它的M S S可达1 4 5 2字节。

如果目的I P地址为“非本地的( n o n l o c a l )”，M S S通常的默认值为5 3 6。而区分地址是本地还是非本地是简单的，如果目的I P地址的网络号与子网号都和我们的相同，则是本地的；如果目的I P地址的网络号与我们的完全不同，则是非本地的；如果目的I P地址的网络号与我们的相同而子网号与我们的不同，则可能是本地的，也可能是非本地的。大多数T C P实现版都提供了一个配置选项（附录E和图E - 1），让系统管理员说明不同的子网是属于本地还是非本地。这个选项的设置将确定M S S可以选择尽可能的大（达到外出接口的M T U长度）或是默认值5 3 6。

M S S让主机限制另一端发送数据报的长度。加上主机也能控制它发送数据报的长度，这将使以较小M T U连接到一个网络上的主机避免分段。

只有当一端的主机以小于5 7 6字节的M T U直接连接到一个网络中，避免这种分段才会有效。如果两端的主机都连接到以太网上，都采用5 3 6的M S S，但中间网络采用2 9 6的M T U，也将会出现分段。使用路径上的M T U发现机制（参见2 4 . 2节）是关于这个问题的唯一方法。

以上说明MSS的值可以通过协商解决，这个协商过程会涉及MTU的值的大小，前面说了：【MSS=外出接口上的MTU-IP首部-TCP首部】，我们来看看数据进入TCP协议栈的封装过程：

最后一层以太网帧的大小应该就是我们的出口ＭＴＵ大小了。当目的主机收到一个以太网数据帧时，数据就开始从协议栈中由底向上升，同时去掉各层协议加上的报文首部。每层协议盒都要去检查报文首部中的协议标识，以确定接收数据的上层协议。这个过程称作分用（ D e m u l t i p l e x i n g），图1 - 8显示了该过程是如何发生的。

那么什么是MTU呢，这实际上是数据链路层的一个概念，以太网和802.3这两种局域网技术标准都对“链路层”的数据帧有大小限制：

最大传输单元MTU

正如在图2 - 1看到的那样，以太网和8 0 2 . 3对数据帧的长度都有一个限制，其最大值分别是1 5 0 0和1 4 9 2字节。链路层的这个特性称作M T U，最大传输单元。不同类型的网络大多数都有一个上限。

如果I P层有一个数据报要传，而且数据的长度比链路层的M T U还大，那么I P层就需要进行分片（ f r a g m e n t a t i o n），把数据报分成若干片，这样每一片都小于M T U。我们将在11 . 5节讨论I P分片的过程。

图2 - 5列出了一些典型的M T U值，它们摘自RFC 1191[Mogul and Deering 1990]。点到点的链路层（如S L I P和P P P）的M T U并非指的是网络媒体的物理特性。相反，它是一个逻辑限制，目的是为交互使用提供足够快的响应时间。在2 . 1 0节中，我们将看到这个限制值是如何计算出来的。在3 . 9节中，我们将用n e t s t a t命令打印出网络接口的M T U。

ＴＣＰ的超时与重传

前面谈到TCP如何保证传输可靠性是说到“当T C P发出一个段后，它启动一个定时器，等待目的端确认收到这个报文段。如果不能及时收到一个确认，将重发这个报文段”，下面我看一下TCP的超时与重传。

T C P提供可靠的运输层。它使用的方法之一就是确认从另一端收到的数据。但数据和确认都有可能会丢失。T C P通过在发送时设置一个定时器来解决这种问题。如果当定时器溢出时还没有收到确认，它就重传该数据。对任何实现而言，关键之处就在于超时和重传的策略，即怎样决定超时间隔和如何确定重传的频率。

对每个连接，T C P管理4个不同的定时器。

1) 重传定时器使用于当希望收到另一端的确认。

2) 坚持( p e r s i s t )定时器使窗口大小信息保持不断流动，即使另一端关闭了其接收窗口。

3) 保活( k e e p a l i v e )定时器可检测到一个空闲连接的另一端何时崩溃或重启。

4) 2MSL定时器测量一个连接处于T I M E _ WA I T状态的时间。

T C P超时与重传中最重要的部分就是对一个给定连接的往返时间（ RT T）的测量。由于路由器和网络流量均会变化，因此我们认为这个时间可能经常会发生变化， T C P应该跟踪这些变化并相应地改变其超时时间。

大多数源于伯克利的T C P实现在任何时候对每个连接仅测量一次RT T值。在发送一个报文段时，如果给定连接的定时器已经被使用，则该报文段不被计时。

TCP经受延时的确认

交互数据总是以小于最大报文段长度的分组发送。对于这些小的报文段，接收方使用经受时延的确认方法来判断确认是否可被推迟发送，以便与回送数据一起发送。这样通常会减少报文段的数目。

通常T C P在接收到数据时并不立即发送A C K；相反，它推迟发送，以便将A C K与需要沿该方向发送的数据一起发送（有时称这种现象为数据捎带A C K）。绝大多数实现采用的时延为200 ms，也就是说，T C P将以最大200 ms 的时延等待是否有数据一起发送。

结论：

1. TCP提供了面向“连续字节流”的可靠的传输服务，TCP并不理解流所携带的数据内容，这个内容需要应用层自己解析。

2. “字节流”是连续的、非结构化的，而我们的应用需要的是有序的、结构化的数据信息，因此我们需要定义自己的“规则”去解读这个“连续的字节流“，那解决途径就是定义自己的封包类型，然后用这个类型去映射“连续字节流”。

如何定义封包，我们回顾一下前面这个数据进入协议栈的封装过程图：

封包其实就是将上图中进入协议栈的用户数据[即用户要发送的数据]定义为一种方便识别和交流的类型，这有点类似信封的概念,信封就是一种人们之间通信的格式,信封格式如下：

信封格式：

收信人邮编

收信人地址

收信人姓名

信件内容

那么在程序里面我们也需要定义这种格式：在C++里面只有结构和类这种两种类型适合表达这个概念了。网络上很多朋友对此表述了自己的看法并贴出了代码：比如

/************************************************************************/

/* 数据封包信息定义开始 */

/************************************************************************/

#pragma pack(push,1) //将原对齐方式压栈,采用新的1字节对齐方式

/* 封包类型枚举[此处根据需求列举] */

typedef enum{

NLOGIN=1,

NREG=2,

NBACKUP=3,

NRESTORE=3,

NFILE_TRANSFER=4,

NHELLO=5

} PACKETTYPE;

/* 包头 */

typedef struct tagNetPacketHead{

byte version;//版本

PACKETTYPE ePType;//包类型

WORD nLen;//包体长度

} NetPacketHead;

/* 封包对象[包头&包体] */

typedef struct tagNetPacket{

NetPacketHead netPacketHead;//包头

char * packetBody;//包体

} NetPacket;

#pragma pack(pop)

/**************数据封包信息定义结束**************************/

3. 发包顺序与收包问题

a) 由于TCP要通过协商解决发送出去的报文段的长度，因此我们发送的数据很有可能被分割甚至被分割后再重组交给网络层发送，而网络层又是采用分组传送，即网络层数据报到达目标的顺序完全无法预测，那么收包会出现半包、粘包问题。举个例子，发送端连续发送两端数据msg1和msg2，那么发送端[传输层]可能会出现以下情况：

i. Msg1和msg2小于TCP的MSS，两个包按照先后顺序被发出，没有被分割和重组

ii. Msg1过大被分割成两段TCP报文msg1-1、msg2-2进行传送,msg2较小直接被封装成一个报文传送

iii. Msg1过大被分割成两段TCP报文msg1-1、msg2-2,msg1-1先被传送,剩下的msg1-2和msg2[较小]被组合成一个报文传送

iv. Msg1过大被分割成两段TCP报文msg1-1、msg2-2,msg1-1先被传送,剩下的msg1-2和msg2[较小]组合起来还是太小,组合的内容在和后面再发送的msg3的前部分数据组合起来发送

v. ……………………….太多……………………..

b) 接收端[传输层]可能出现的情况

i. 先收到msg1,再收到msg2,这种方式太顺利了。

ii. 先收到msg1-1，再收到msg1-2，再收到msg2

iii. 先收到msg1，再收到msg2-1,再收到msg2-2

iv. 先收到msg1和msg2-1,再收到msg2-2

v. //…………还有很多………………

c) 其实“接收端网络层”接收到的分组数据报顺序和发送端比较可能完全是乱的，比如发“送端网络层”发送1、2、3、4、5，而接收端网络层接收到的数据报顺序却可能是2、1、5、4、3，但是“接收端的传输层”会保证链接的有序性和可靠性，“接收端的传输层”会对“接收端网络层”收到的顺序紊乱的数据报重组成有序的报文[即发送方传输层发出的顺序]，然后交给“接收端应用层”使用，所以“接收端传输层”总是能够保证数据包的有序性，“接收端应用层”[我们编写的socket程序]不用担心接收到的数据的顺序问题。

d) 但是如上所述，粘包问题和半包问题不可避免。我们在接收端应用层需要自己编码处理粘包和半包问题。一般做法是定义一个缓冲区或者是使用标准库/框架提供的容器循环存放接收到数据，边接收变判断缓冲区数据是否满足包头大小，如果满足包头大小再判断缓冲区剩下数据是否满足包体大小，如果满足则提取。详细步骤如下：

1. 接收数据存入缓冲区尾部

2. 缓冲区数据满足包头大小否

3. 缓冲区数据不满足包头大小，回到第1步；缓冲区数据满足包头大小则取出包头，接着判断缓冲区剩余数据满足包头中定义的包体大小否，不满足则回到第1步。

4. 缓冲区数据满足一个包头大小和一个包体大小之和，则取出包头和包体进行使用,此处使用可以采用拷贝方式转移缓冲区数据到另外一个地方，也可以为了节省内存直接采取调用回调函数的方式完成数据使用。

5. 清除缓冲区的第一个包头和包体信息，做法一般是将缓冲区剩下的数据拷贝到缓冲区首部覆盖“第一个包头和包体信息”部分即可。

粘包、半包处理具体实现很多朋友都有自己的做法，比如最前面贴出的链接，这里我也贴出一段参考：

缓冲区实现头文件：
#include <windows.h>
 
#ifndef _CNetDataBuffer_H_
#define _CNetDataBuffer_H_
 
#ifndef TCPLAB_DECLSPEC
#define TCPLAB_DECLSPEC _declspec(dllimport)
#endif
 
/************************************************************************/
/* 数据封包信息定义开始                                                 */
/************************************************************************/
 
#pragma pack(push,1)   //将原对齐方式压栈,采用新的1字节对齐方式
 
/* 封包类型枚举[此处根据需求列举] */
typedef enum{
              NLOGIN=1,
              NREG=2,
              NBACKUP=3,
              NRESTORE=3,
              NFILE_TRANSFER=4,
              NHELLO=5
} PACKETTYPE;
 
/* 包头 */
typedef struct tagNetPacketHead{
       byte version;//版本
       PACKETTYPE ePType;//包类型
       WORD nLen;//包体长度
} NetPacketHead;
 
/* 封包对象[包头&包体] */
typedef struct tagNetPacket{
       NetPacketHead netPacketHead;//包头
       char * packetBody;//包体
} NetPacket;
 
#pragma pack(pop)
/**************数据封包信息定义结束**************************/
 
//缓冲区初始大小
#define BUFFER_INIT_SIZE 2048
 
//缓冲区膨胀系数[缓冲区膨胀后的大小=原大小+系数*新增数据长度]
#define BUFFER_EXPAND_SIZE 2
 
//计算缓冲区除第一个包头外剩下的数据的长度的宏[缓冲区数据总长度-包头大小]
#define BUFFER_BODY_LEN (m_nOffset-sizeof(NetPacketHead))
 
//计算缓冲区数据当前是否满足一个完整包数据量[包头&包体]
#define HAS_FULL_PACKET ( \
                                                 (sizeof(NetPacketHead)<=m_nOffset) && \
                                                 ((((NetPacketHead*)m_pMsgBuffer)->nLen) <= BUFFER_BODY_LEN) \
                                          )
 
//检查包是否合法[包体长度大于零且包体不等于空]
#define IS_VALID_PACKET(netPacket) \
       ((netPacket.netPacketHead.nLen>0) && (netPacket.packetBody!=NULL))
 
//缓冲区第一个包的长度
#define FIRST_PACKET_LEN (sizeof(NetPacketHead)+((NetPacketHead*)m_pMsgBuffer)->nLen)
 
/* 数据缓冲 */
class /*TCPLAB_DECLSPEC*/ CNetDataBuffer
{
       /* 缓冲区操作相关成员 */
private:
       char *m_pMsgBuffer;//数据缓冲区
       int m_nBufferSize;//缓冲区总大小
       int m_nOffset;//缓冲区数据大小
public:
       int GetBufferSize() const;//获得缓冲区的大小
       BOOL ReBufferSize(int);//调整缓冲区的大小
       BOOL IsFitPacketHeadSize() const;//缓冲数据是否适合包头大小
       BOOL IsHasFullPacket() const;//缓冲区是否拥有完整的包数据[包含包头和包体]      
       BOOL AddMsg(char *pBuf,int nLen);//添加消息到缓冲区
       const char *GetBufferContents() const;//得到缓冲区内容
       void Reset();//缓冲区复位[清空缓冲区数据,但并未释放缓冲区]
       void Poll();//移除缓冲区首部的第一个数据包
public:
       CNetDataBuffer();
       ~CNetDataBuffer();
};
 
#endif
 
缓冲区实现文件:
#define TCPLAB_DECLSPEC _declspec(dllexport)
 
#include "CNetDataBuffer.h"
 
/* 构造 */
CNetDataBuffer::CNetDataBuffer()
{
       m_nBufferSize = BUFFER_INIT_SIZE;//设置缓冲区大小
       m_nOffset = 0;//设置数据偏移值[数据大小]为0
       m_pMsgBuffer = NULL;
       m_pMsgBuffer = new char[BUFFER_INIT_SIZE];//分配缓冲区为初始大小
       ZeroMemory(m_pMsgBuffer,BUFFER_INIT_SIZE);//缓冲区清空   
}
 
/* 析构 */
CNetDataBuffer::~CNetDataBuffer()
{
       if (m_nOffset!=0)
       {
              delete [] m_pMsgBuffer;//释放缓冲区
              m_pMsgBuffer = NULL;
              m_nBufferSize=0;
              m_nOffset=0;
       }
}
 
 
 
/************************************************************************/
/* Description:       获得缓冲区中数据的大小                                  */
/* Return:              缓冲区中数据的大小                                                                   */
/************************************************************************/
INT CNetDataBuffer::GetBufferSize() const
{
       return this->m_nOffset;
}
 
 
/************************************************************************/
/* Description:       缓冲区中的数据大小是否足够一个包头大小                  */
/* Return:              如果满足则返回True,否则返回False
/************************************************************************/
BOOL CNetDataBuffer::IsFitPacketHeadSize() const
{
       return sizeof(NetPacketHead)<=m_nOffset;
}
 
/************************************************************************/
/* Description:       判断缓冲区是否拥有完整的数据包(包头和包体)              */
/* Return:              如果缓冲区包含一个完整封包则返回True,否则False                   */
/************************************************************************/
BOOL CNetDataBuffer::IsHasFullPacket() const
{
       //如果连包头大小都不满足则返回
       //if (!IsFitPacketHeadSize())
       //     return FALSE;
 
       return HAS_FULL_PACKET;//此处采用宏简化代码
}
 
/************************************************************************/
/* Description:       重置缓冲区大小                                                  */
/* nLen:          新增加的数据长度                                                                      */
/* Return:              调整结果                                                                                    */
/************************************************************************/
BOOL CNetDataBuffer::ReBufferSize(int nLen)
{
       char *oBuffer = m_pMsgBuffer;//保存原缓冲区地址
       try
       {
              nLen=(nLen<64?64:nLen);//保证最小增量大小
              //新缓冲区的大小=增加的大小+原缓冲区大小
              m_nBufferSize = BUFFER_EXPAND_SIZE*nLen+m_nBufferSize;          
              m_pMsgBuffer = new char[m_nBufferSize];//分配新的缓冲区,m_pMsgBuff指向新缓冲区地址
              ZeroMemory(m_pMsgBuffer,m_nBufferSize);//新缓冲区清零
              CopyMemory(m_pMsgBuffer,oBuffer,m_nOffset);//将原缓冲区的内容全部拷贝到新缓冲区
       }
       catch(...)
       {
              throw;
       }
 
       delete []oBuffer;//释放原缓冲区
       return TRUE;
}
 
/************************************************************************/
/* Description:       向缓冲区添加消息                                        */
/* pBuf:          要添加的数据                                                                             */
/* nLen:          添加的消息长度
/* return:        添加成功返回True,否则False                                                      */
/************************************************************************/
BOOL CNetDataBuffer::AddMsg(char *pBuf,int nLen)
{
       try
       {
              //检查缓冲区长度是否满足,不满足则重新调整缓冲区大小
              if (m_nOffset+nLen>m_nBufferSize)
                     ReBufferSize(nLen);
             
              //拷贝新数据到缓冲区末尾 
              CopyMemory(m_pMsgBuffer+sizeof(char)*m_nOffset,pBuf,nLen);
             
              m_nOffset+=nLen;//修改数据偏移
       }
       catch(...)
       {
              return FALSE;
       }
       return TRUE;
}
 
/* 得到缓冲区内容 */
const char * CNetDataBuffer::GetBufferContents() const
{
       return m_pMsgBuffer;
}
 
/************************************************************************/
/* 缓冲区复位                                                           */
/************************************************************************/
void CNetDataBuffer::Reset()
{
      
       if (m_nOffset>0)
       {
              m_nOffset = 0;
              ZeroMemory(m_pMsgBuffer,m_nBufferSize);
       }
}
 
/************************************************************************/
/* 移除缓冲区首部的第一个数据包                                         */
/************************************************************************/
void CNetDataBuffer::Poll()
{
       if(m_nOffset==0 || m_pMsgBuffer==NULL)
              return;
       if (IsFitPacketHeadSize() && HAS_FULL_PACKET)
       {           
              CopyMemory(m_pMsgBuffer,m_pMsgBuffer+FIRST_PACKET_LEN*sizeof(char),m_nOffset-FIRST_PACKET_LEN);
       }
}
 
对TCP发包和收包进行简单封装：
头文件：
#include <windows.h>
#include "CNetDataBuffer.h"
 
// #ifndef TCPLAB_DECLSPEC
// #define TCPLAB_DECLSPEC _declspec(dllimport)
// #endif
 
 
#ifndef _CNETCOMTEMPLATE_H_
#define _CNETCOMTEMPLATE_H_
 
 
//通信端口
#define TCP_PORT 6000
 
/* 通信终端[包含一个Socket和一个缓冲对象] */
typedef struct {
       SOCKET m_socket;//通信套接字
       CNetDataBuffer m_netDataBuffer;//该套接字关联的数据缓冲区
} ComEndPoint;
 
/* 收包回调函数参数 */
typedef struct{
       NetPacket *pPacket;
       LPVOID processor;
       SOCKET comSocket;
} PacketHandlerParam;
 
class CNetComTemplate{     
       /* Socket操作相关成员 */
private:
      
public:
       void SendPacket(SOCKET m_connectedSocket,NetPacket &netPacket);//发包函数
       BOOL RecvPacket(ComEndPoint &comEndPoint,void (*recvPacketHandler)(LPVOID)=NULL,LPVOID=NULL);//收包函数
public:
       CNetComTemplate();
       ~CNetComTemplate();
};
 
#endif
 
 
实现文件：
 
#include "CNetComTemplate.h"
 
CNetComTemplate::CNetComTemplate()
{
 
}
 
CNetComTemplate::~CNetComTemplate()
{
 
}
 
/************************************************************************/
/* Description:发包                                                     */
/* m_connectedSocket:建立好连接的套接字                                                             */
/* netPacket:要发送的数据包                                                                                   */
/************************************************************************/
void CNetComTemplate::SendPacket(SOCKET m_connectedSocket,NetPacket &netPacket)
{
       if (m_connectedSocket==NULL || !IS_VALID_PACKET(netPacket))//如果尚未建立连接则退出
       {
              return;
       }
       ::send(m_connectedSocket,(char*)&netPacket.netPacketHead,sizeof(NetPacketHead),0);//先发送包头
       ::send(m_connectedSocket,netPacket.packetBody,netPacket.netPacketHead.nLen,0);//在发送包体
}
 
/**************************************************************************/
/* Description:收包                                                       */
/* comEndPoint:通信终端[包含套接字和关联的缓冲区]                                     */
/* recvPacketHandler:收包回调函数,当收到一个包后调用该函数进行包的分发处理*/
/**************************************************************************/
BOOL CNetComTemplate::RecvPacket(ComEndPoint &comEndPoint,void (*recvPacketHandler)(LPVOID),LPVOID pCallParam)
{
       if (comEndPoint.m_socket==NULL)
              return FALSE;
      
       int nRecvedLen = 0;
       char pBuf[1024];
       //如果缓冲区数据不够包大小则继续从套接字读取tcp报文段
       while (!(comEndPoint.m_netDataBuffer.IsHasFullPacket()))
       {
              nRecvedLen = recv(comEndPoint.m_socket,pBuf,1024,0);
             
              if (nRecvedLen==SOCKET_ERROR || nRecvedLen==0)//若果Socket错误或者对方连接已经正常关闭则结束读取
                     break;
              comEndPoint.m_netDataBuffer.AddMsg(pBuf,nRecvedLen);//将新接收的数据存入缓冲区
       }
 
       //执行到此处可能是三种情况:
       //1.已经读取到的数据满足一个完整的tcp报文段
       //2.读取发生socket_error错误
       //3.在还未正常读取完毕的过程中对方连接已经关闭
      
 
       //如果没有读取到数据或者没有读取到完整报文段则返回返回
       if (nRecvedLen==0 || (!(comEndPoint.m_netDataBuffer.IsHasFullPacket())))
       {
              return FALSE;
       }
 
       if (recvPacketHandler!=NULL)
       {
              //构造准备传递给回调函数的数据包
              NetPacket netPacket;
              netPacket.netPacketHead = *(NetPacketHead*)comEndPoint.m_netDataBuffer.GetBufferContents();
              netPacket.packetBody = new char[netPacket.netPacketHead.nLen];//动态分配包体空间
             
              //构造回调函数参数
              PacketHandlerParam packetParam;
              packetParam.pPacket = &netPacket;
              packetParam.processor = pCallParam;
 
              //呼叫回调函数
              recvPacketHandler(&packetParam);
 
              delete []netPacket.packetBody;
       }
 
       //移除缓冲区的第一个包
       comEndPoint.m_netDataBuffer.Poll();
 
       return TRUE;
}

参考链接：http://blog.youkuaiyun.com/pi9nc/article/details/17165171