UDP分包重组算法

最新推荐文章于 2024-06-14 20:45:00 发布
最新推荐文章于 2024-06-14 20:45:00 发布
阅读量6.1k 收藏 11
点赞数

分享到

 

 本文摘自：http://www.rosoo.net/a/201009/10078.html

 

UDP分包重组算法（BTW：Windows下用IOCP来发也可能会有同样的问题，所以本文同样适用于TCP - IOCP下的分包及重组）
 
  Packet.h

1.            #include  "InetAddr.h" //对socket地址操作封装的类，比如char*IP转成ULONG

2.            #include  <vector>

3.            using namespace  std;

4.             

5.            //先定义包头

6.            typedef struct  _HeadExt

7.            {

8.                //每帧所有分片公用信息

9.                char    flag[5]; //可以任意字符或数字或其他方法，用来标志我们发送的数据

10.           UINT   m_nSeqNumber; //本帧序数

11.           USHORT  m_nTotalFragment;//本帧数据可分成的总片数

12.           USHORT  m_nTotalSize;  //本帧数据总长度

13.           //每片各自信息

14.           USHORT  m_nFragmentIndex; //每帧分片序数,0 1 2  ... ,\

15.           USHORT  m_usPayloadSize; //本片数据长度

16.           USHORT  m_usFragOffset;//本片数据相对总数据的偏移量

17.           USHORT  m_bLastFragment;//是否最后一帧

18.       //上 述数据有些重复，可以精简，有时间再修改

19.        }HeadExt;

20.        

21.        

22.        

23.       //从socket接收到的数据 

24.       class  PacketIn

25.       {

26.       public :

27.           PacketIn(char*  lpszBuffer=NULL, UINT usBufferSize=0, UINT nDataSize=0);

28.           virtual  ~PacketIn();

29.           HeadExt head; 

30.           BYTE*    m_lpszBuffer;

31.           ULONG   ip;

32.           UINT    port;

33.           CVLInetAddr  addr;

34.           BOOL  Normalize();

35.           UINT   m_nDataLen;

36.           UINT   m_usBufferSize;

37.        

38.       };

39.        

40.       //接收到数据后开始重组使用的一个中间缓冲区，多个PacketIn合成一个Packet

41.       //发送时从一个Packet分割出多片，不过本程序里直接发送，没有封成Packet

42.       class Packet 

43.       {

44.       public:

45.           enum {  TIMEOUT_LOCKFRAGMENTS = 1000 };

46.           Packet( );

47.           ~Packet();

48.           void reset();

49.           void Set(const  CVLInetAddr& iaFrom, UINT nSeqNumber );

50.           BOOL  InsertFragment(PacketIn* const pFragment);

51.           bool m_bUsed; 

52.           int  recvedpacks;

53.           int  recvedbytes;

54.           int seqnum;

55.           BYTE*  m_pBuffer;

56.        

57.       //测试用程序，直接访问了类的变量，没有封装成函数。上述变量正常应该写成 SetXXX ,GetXXX    

58.       private:

59.           BOOL IsFragComplete() const;

60.           ULONG     m_ip;

61.           USHORT   m_port;

62.           UINT        m_nSeqNumber;

63.           vector<int>  SeqNumberList;

64.       };

Packet.cpp

1.            #include  "Packet.h"

2.             

3.            PacketIn::PacketIn(char*  lpszBuffer/*=NULL*/, UINT usBufferSize/*=0*/,

4.             UINT nDataSize/*=0*/)

5.            {

6.             

7.                m_lpszBuffer   = (BYTE*)lpszBuffer;

8.                m_usBufferSize = usBufferSize; //数据最大长度，其实没什么用，已经设置了这个值最大为64000

9.                m_nDataLen = nDataSize;

10.       }

11.       PacketIn::~PacketIn()

12.       {

13.       }

14.       BOOL PacketIn::Normalize()  //判断收到的数据是否有效

15.       {

16.           const USHORT  usHeaderSize = sizeof(HeadExt);

17.           if (  !m_lpszBuffer || m_usBufferSize < usHeaderSize )//没什么用

18.           {

19.               return  FALSE;

20.           }

21.        

22.           HeadExt*  pHeader = (HeadExt*)( m_lpszBuffer  );

23.           if (  pHeader->m_usPayloadSize != m_nDataLen - usHeaderSize )

24.           {

25.               return  FALSE;

26.           }

27.        

28.           head =  *pHeader;

29.           if (  pHeader->m_usPayloadSize > 0 )

30.           {

31.       memmove( m_lpszBuffer, m_lpszBuffer + usHeaderSize,  pHeader->m_usPayloadSize );

32.           }

33.           

34.           return TRUE;

35.       }

36.        

37.       /

38.       //这里是重组数据的临时缓冲，只看这里必然迷惑，先看socket收数据那里，再回来查看

39.       void Packet::Set( const CVLInetAddr& iaFrom, UINT  nSeqNumber )

40.       {

41.           m_iaFrom  =  iaFrom;

42.           m_nSeqNumber  = nSeqNumber;

43.           if(m_pBuffer) 

44.               delete  []m_pBuffer;

45.       }

46.        

47.       void Packet::reset()

48.       {

49.           m_bUsed = false; 

50.           recvedpacks =  0;

51.           seqnum = 0;

52.           recvedbytes =  0;

53.           m_pBuffer =  NULL;

54.           m_pBuffer = new  BYTE[64000];

55.           SeqNumberList.clear();

56.       }

57.       Packet::Packet()

58.       {

59.           //calculate  the ttl

60.           //m_nTTL =  RUDP_REASSEMBLE_TIMEOUT*CRudpPeer::PR_SLOWHZ;

61.           reset();

62.       }

63.        

64.       Packet::~Packet()

65.       {

66.           if(m_pBuffer) 

67.               delete  []m_pBuffer;

68.       }

69.        

70.       BOOL Packet::InsertFragment(PacketIn* const pFragment)

71.       {

72.           int nSize =  SeqNumberList.size();

73.           for(int i =  0; i< nSize ;i ++)

74.           {

75.               if(nSize ==SeqNumberList[i] )//收到重复数据包

76.               {

77.                   return  FALSE;

78.               }

79.           }

80.           SeqNumberList.push_back(pFragment->head.m_nFragmentIndex); 

81.        

82.           memcpy(  m_pBuffer + pFragment->head.m_usFragOffset,

83.       pFragment->m_lpszBuffer, pFragment->head.m_usPayloadSize); 

84.           recvedbytes  += pFragment->head.m_usPayloadSize;

85.           recvedpacks++;

86.           m_bUsed = true; 

87.        

88.           CString str;

89.       str.Format("收到数据：m_nSeqNumber%d ,m_nTotalFragment %d,m_nFragmentIndex %d,

90.       m_usFragOffset %d,m_nTotalSize %d,recvedbytes  %d\r\n",

91.       pFragment->head.m_nSeqNumber,pFragment->head.m_nTotalFragment, 

92.       pFragment->head.m_nFragmentIndex,pFragment->head.m_usFragOffset, 

93.       pFragment->head.m_nTotalSize,pFragment->head.m_usPayloadSize); 

94.               OutputDebugString(str);

95.        

96.           if(recvedbytes  == pFragment->head.m_nTotalSize )

97.               return  TRUE;

98.           

99.           return FALSE; 

100.   }

发送时的操作：

1.            #iclude  "packet.h"

2.             

3.            const int  RTP_SPLIT_PACKSIZE = 1300;

4.            //udp一般最大包为1500,一般这里都设置为1400，当然1300也没错

5.            LONGLONG index =  rand();

6.            //帧序数，从一个随机数开始，我机器上生成的是41

7.            //分包发送,逻辑相当简单，按最常规的方法分割发送

8.            void Send(BYTE*  pBuff,UINT nLen,ULONG ip,USHORT port)

9.            {

10.           HeadExt head; 

11.           strcpy(head.flag ,"aaaa");

12.             

13.           head.m_nSeqNumber = index++; //帧序数

14.        

15.           head.m_nTotalFragment =  nLen/RTP_SPLIT_PACKSIZE;

16.           head.m_nTotalFragment  += nLen%RTP_SPLIT_PACKSIZE?1:0;

17.       //整除的话就是0，否则多出一个尾数据 

18.           head.m_nFragmentIndex = 0;//第一个分段从0开始

19.           head.m_nTotalSize = nLen;

20.           head.m_bLastFragment = 0;

21.           head.m_usFragOffset = 0;

22.        

23.           char  tem[RTP_SPLIT_PACKSIZE+sizeof(HeadExt)];

24.        

25.           if(head.m_nTotalFragment == 1)

26.           {

27.               memcpy(tem,&head,sizeof(HeadExt)); 

28.               memcpy(tem+sizeof(HeadExt),pBuff,nLen); 

29.               head.m_usPayloadSize = nLen;

30.        

31.       //用UDP发送，常规做法，先对UDP做一个封装的类，这里调用类对象。本代码只说明原理，类似伪代友

32.              sendto(tem,nLen+sizeof(HeadExt),ip,port); 

33.        

34.               CString  str;

35.               str.Format("发送数据：m_nSeqNumber%d ,m_nTotalFragment %d,m_nFragmentIndex %d,

36.       m_usFragOffset %d,m_nTotalSize %d,m_nDataLen  %d\r\n",

37.       head.m_nSeqNumber,head.m_nTotalFragment,head.m_nFragmentIndex,

38.       head.m_usFragOffset,head.m_nTotalSize,head.m_usPayloadSize); 

39.               OutputDebugString(str);

40.        

41.               return;

42.           }

43.        

44.           int i = 0;

45.           for( i = 0; i  < head.m_nTotalFragment-1; i++)//开始分割,最后一个单独处理

46.           {

47.               head.m_bLastFragment = 0;

48.               head.m_nFragmentIndex = i;

49.               head.m_usFragOffset =  i*RTP_SPLIT_PACKSIZE;

50.               head.m_usPayloadSize =  RTP_SPLIT_PACKSIZE;

51.               memcpy(tem,&head,sizeof(HeadExt)); 

52.               memcpy(tem+sizeof(HeadExt),pBuff+i*RTP_SPLIT_PACKSIZE,RTP_SPLIT_PACKSIZE); 

53.              sendto(tem,nLen+sizeof(HeadExt),ip,port); 

54.        

55.               CString  str;

56.               str.Format("发送数据：m_nSeqNumber%d ,m_nTotalFragment  %d,m_nFragmentIndex %d,

57.       m_usFragOffset %d,m_nTotalSize %d,m_nDataLen  %d\r\n",

58.       head.m_nSeqNumber,head.m_nTotalFragment,head.m_nFragmentIndex,

59.       head.m_usFragOffset,head.m_nTotalSize,head.m_usPayloadSize); 

60.               OutputDebugString(str);

61.        

62.           }

63.        

64.           head.m_bLastFragment = 1;

65.           head.m_nFragmentIndex = i;

66.           head.m_usFragOffset =  i*RTP_SPLIT_PACKSIZE;

67.           head.m_usPayloadSize = nLen -  (i*RTP_SPLIT_PACKSIZE);

68.        

69.           memcpy(tem,&head,sizeof(HeadExt));

70.           memcpy(tem+sizeof(HeadExt),pBuff+i*RTP_SPLIT_PACKSIZE,nLen  - (i*RTP_SPLIT_PACKSIZE));

71.        

72.           sendto(tem,nLen+sizeof(HeadExt),ip,port); 

73.        

74.           CString str;

75.       str.Format("发送数据：m_nSeqNumber%d ,m_nTotalFragment %d,m_nFragmentIndex %d,

76.       m_usFragOffset %d,m_nTotalSize %d,m_nDataLen  %d\r\n",head.m_nSeqNumber,

77.       head.m_nTotalFragment,head.m_nFragmentIndex,head.m_usFragOffset,

78.       head.m_nTotalSize,head.m_usPayloadSize);

79.        

80.       OutputDebugString(str);

81.       }

接收数据的回调
 
  //代码很简单，收到数据后，形成PacketIn，然后找一个链表，插进去
  //因为收到的数据的顺序是不定的，所以先创建一个链表，每帧首数据到来时，分配一个节点，其他分片到来的时候，都加到//这个节点里,等数据都到齐了，这个节点就是一个完整的包，回调出去。

1.            void  RecvCallback(BYTE* pBuff,UINT nLen,ULONG ip,USHORT port)

2.            {

3.                if(nLen < sizeof(HeadExt))

4.                    return;

5.                HeadExt* pHead = (HeadExt*)pBuff;

6.                CString str = pHead->flag;

7.                if(str != "aaaa")

8.                {

9.                    return;

10.           }

11.           if(pHead->m_nTotalFragment  == 1)//只有一帧，不分片

12.           {

13.               //回调，上层处理

14.               if(m_pfDispatch)

15.       m_pfDispatch(pBuff+sizeof(HeadExt),nLen-sizeof(HeadExt),ip,port,m_lpParam);

16.               return;

17.           }

18.        

19.           PacketIn  data( (char*)pBuff, 64000, nLen );

20.           if (  !data.Normalize() )

21.               return;

22.           if (  data.head.m_nTotalFragment>1 )

23.           {

24.               Packet*  pTemp = GetPartialPacket( iaRemote, data.head.m_nSeqNumber );

25.               if (  pTemp )

26.               {

27.                   if (  pTemp ->InsertFragment( &data ) )

28.                   {

29.                       m_pfDispatch(pTemp  ->m_pBuffer,

30.                           pTemp  ->recvedbytes,ip,port,m_lpParam);

31.                   }

32.               }//end of  if

33.           }

34.       }

//上面用到的一些变量可以在一个.h里面定义，比如：
  Packet TempPacket[16];//分配一个数组，每个节点是一个重组后临时缓冲
  Packet* GetPartialPacket(const CVLInetAddr& iaFrom, UINT nSeqNumber);//从数组里取出一个缓冲节点

1.            //根据这几个关键字查找，不过只用

2.            //到了nSeqNumber,要是3人以上的视频聊天，ip和port是必要的

3.            Packet*  GetPartialPacket(const ULONG ip,USHORT port, UINT nSeqNumber)

4.            {

5.                Packet* tmp = NULL;

6.                int i=0;

7.                while(tmp==NULL && i<16)

8.                {

9.                    //该包所属的帧已有其它数据包到达

10.               if(TempPacket[i].seqnum==nSeqNumber  && TempPacket[i].recvedpacks>0)

11.               {

12.                   tmp =  &TempPacket[i];

13.                   break; 

14.               }

15.               i++;

16.           }

17.           if(tmp ==  NULL)        //新的帧

18.           {

19.               //查找空闲元素

20.               for(i=0;i<16;i++) 

21.               {

22.                   if(!TempPacket[i].m_bUsed)

23.                       break; 

24.               }

25.        

26.               if(i>=16) 

27.               {

28.                   //没有空闲的元素，丢掉一个最早

29.                   tmp =  &TempPacket[0];

30.                   int j  = 0;

31.                   for(i=1;i<16;i++) 

32.                   {

33.                       if(TempPacket[i].seqnum  < tmp->seqnum)

34.                       { 

35.                           tmp = &TempPacket[i]; 

36.                           j = i;

37.                       } 

38.                   }

39.                   //找到最早的一帧

40.                   if(tmp->m_pBuffer) 

41.                   {

42.                       delete  []tmp->m_pBuffer;

43.                       tmp->reset();

44.                   }

45.               }

46.               else

47.                   tmp =  &TempPacket[i];

48.           }

49.        

50.           InsertFragment

51.           tmp->m_bUsed = true;

52.           tmp->seqnum = nSeqNumber;

53.        

54.           return tmp;

55.       }


  整个示例最重要的是两个函数：
 
  GetPartialPacket：取到一个临时缓冲节点
 
  InsertFragment：把收到的每个数据段插入临时缓冲组成一个完整帧
 
  当然发送方也要按一定规则分割发送。

 

 

bird67
关注
  • 0
    点赞
  • 踩
  • 11
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
【Network】UDP 大包怎么发？ MTU怎么设置？
weixin_33950035的博客
12-26 859
      这里主要用UDP来发送视频，当发送的数据大于1500时分包发送，保证每包小于1500.发送好办，分割后循环发就可以了，关键是接收时的处理。先做一下处理的方法 ：发送时每包上面加上标识，比如RTP的做法是加时间戳，SSRC，媒体类型还有结束标识。简单参考一下，我们也加上一些标识(直接拿RTP头也可以， 不过我们的目标是更简洁一些)。另外，我们的目的和RTP稍有不同，UDP库当时设计是传输...
wireshark录制 UDP 数据分包分片重组
三维点云技术探索
06-11 1753
个人公众号“代码就是生产力”，发布更多有用的工具 对于UDP来说，如果发现数据过大，那么 IP 层会自动对数据进行切割，分片，但是通常应用层我们不会发现有什么影响，因为已经自动合并了分片数据，但是如果是使用 wireshark 录制的数据，就会出现数据分片了，但是没有重组的情况，这个时候，需要我们手动对数据进行一个重组，类似如下的情况： 可以看到，一个数据被分成了8个数据分片，但是他们的ID是一样的，然后有不同的offset，那么我们就可以根据这两个特性，把每组的分片重组起来。 仅仅使用 dpkt 工具即可
UDP 协议详解与实战
最新发布
宾有为的博客
06-14 886
UDP（User Datagram Protocol，用户数据报协议）是一种简单的面向无连接的传输层协议，它提供了一种不可靠的数据传输服务。
UDP分包重组算法2
施昌权专栏
07-14 1355
UDP分包重组算法2，更多技术文章请参看施昌权的个人网站： http://www.joyvc.cn
UDP分包重组算法 1
施昌权专栏
07-14 945
UDP分包重组算法 1，更多技术文章请参看施昌权的个人网站： http://www.joyvc.cn
UDP分包重组算法和 基于RTP的H264视频数据分包重组
seven407的专栏
12-24 3657
UDP分包重组算法 转自：http://blog.csdn.net/sxcong/archive/2009/02/12/3882721.aspx 使用jrtplib3.7.1的主要工作有两个： 一是发送接收数据需要分片和重组。开始采集双向链表，后来发现处理不够好，内存总出错(好久没研究数据结构了)。后来直接采用分配缓冲，发送数据时标志offset,接收数据 按offset直接填充，非常简单。当然接收时判断一下，有没有重复的数据。 二是继承RTPSession，写一个响应类，在这里接收和发送。 然后，写一个
java udp分包重组算法_UDP分包重组算法 1
weixin_39850152的博客
02-27 473
//Packet.h#include "InetAddr.h" //对socket地址操作封装的类，比如char*IP转成ULONG#include using namespace std;//先定义包头typedef struct _HeadExt{//每帧所有分片公用信息char flag[5]; //可以任意字符或数字或其他方法，用来标...
c#udp分包传输
08-28
"c#udp分包传输"这个话题涉及到C#编程语言中如何处理UDP协议的数据分包和重组。下面将详细探讨这一主题。 首先，UDP是一种无连接、不可靠的传输协议，它不像TCP那样保证数据的顺序和完整性。因此，在传输大数据量时...
C#Udp分包传输大文件
12-27
本篇文章将详细阐述如何在C#环境下使用UDP实现大文件的分包传输。 首先，理解UDP的特点是关键。与TCP不同，UDP不保证数据包的顺序、完整性和重传，这意味着在分包传输过程中，我们需要自己处理这些问题。C#中的`...
c#UDP组包分包接收发送
10-27
至于“DataTest”这个文件，很可能是测试数据或者一个测试程序，用于验证我们的UDP分包、组包和重发机制是否正常工作。在测试过程中，我们会创建模拟的网络环境，发送不同大小和类型的测试数据，观察接收端能否正确...
QT通过UDP分包传输大图像（测试可传6M图片）
07-28
QT框架提供了一种方便的方式来处理UDP通信，本篇文章将深入探讨如何使用QT通过UDP分包传输大图像。 首先，我们要理解UDP的特点。UDP是一种无连接的协议，每个数据包都独立发送，没有握手过程，也没有错误检测和重传...
UDP上可靠和不可靠的消息。 强大的邮件分段和重组功能。 加密。-C/C++开发
05-26
GameNetworkingSockets GameNetworkingSockets是游戏的基本传输层。 这些功能包括：面向连接的API（如TCP）...但面向消息（如UDP），而非面向流。 同时支持可靠和u GameNetworkingSockets GameNetworkingSockets是游戏的基本传输层。 这些功能包括：面向连接的API（如TCP）...但面向消息（如UDP），而非面向流。 同时支持可靠和不可靠的消息类型消息可以大于基础MTU。 该协议执行分段，重组和重新传输以获取可靠的消息。 可靠性层比基本的TCP样式的滑动窗口要复杂得多。 它基于“确认
udp分包组包通信
09-30
udp 分包 组包 通信， 此模块是我自己写的 如商用，后果自付 udp通信源代码
Qt通过UDP传图片 实现自定义分包和组包
09-27
Qt通过UDP传图片 实现自定义分包和组包 详见博客：http://blog.csdn.net/caoshangpa/article/details/52681572
基于udp的qq通信
07-08
QQ通信系统需要实现自己的分包和重组算法，确保接收方能够正确地将这些数据包重新组合成原始消息。 3. **心跳机制**：为了保持连接状态，UDP协议本身没有连接的概念，QQ通信会采用心跳包来维持“在线”状态。定时...
UDP—数据报重组
weixin_34248118的博客
05-19 1419
与 TCP 的通信机制不同，由于 UDP 是无连接协议，因此通信发生之前不会建立会话。UDP 是基于事务的，换言之，应用程序要发送数据时，它仅只是发送数据。 很多使用 UDP 的应用程序发送的数据量很小，用一个数据段就够了。但是也有一些应用程序需要发送大量数据，因此需要用多个数据段。UDP PDU 的实际意义是数据报，尽管数据段 和数据报 可以互换使用来描述某个传输...
IP、ICMP、UDP、TCP 校验和算法
rainharder的专栏
10-09 1172
原帖：http://blog.csdn.net/li_xiang1102/article/details/6901660  以前看计算机网络相关的书，每次看到IP或者UDP报头校验和时，都一瞥而过，以为相当简单，不就是16bit数据的相加吗。最近在研究《TCP/IP详解 卷1：协议》这本书，看到校验和是16bit字的二进制反码和（晕，以前都没注意原来是反码和，看来以前看书不仔细啊
java udp分包重组算法_[转]以太网中的UDP编程：udp分包问题
weixin_39631445的博客
02-27 620
最近学习UDP编程，头都搞大了，找了不少资料，也请教了不少同行，自认为下面这篇资料写的很好，所以收藏之，以供参考．1.在进行UDP编程的时候,我们最容易想到的问题就是,一次发送多少bytes好?当然,这个没有唯一答案，相对于不同的系统,不同的要求,其得到的答案是不一样的,我这里仅对像ICQ一类的发送聊天消息的情况作分析，对于其他情况，你或许也能得到一点帮助:首先,我们知道,TCP/IP通常被认为是...
qt udp分包组包
12-20
QT是一种跨平台的C++应用程序开发框架，它包含了丰富的网络通信模块。UDP是一种无连接的网络通信协议，它可以实现高效的数据传输。在QT中，我们可以利用UDP协议进行数据的分包和组包。 首先，对于UDP数据的分包，我们可以通过指定数据包的大小来实现。在QT中，可以使用QUdpSocket类来创建UDP客户端或服务器，然后可以使用writeDatagram方法将需要发送的数据分成指定大小的数据包，并进行发送。当接收端收到这些分包后，可以根据自己的需求进行数据的重组。 其次，对于UDP数据的组包，我们需要在接收端进行数据的重新组合。接收端可以使用QUdpSocket类来创建UDP客户端或服务器，然后通过readyRead信号来监听是否有数据包到达。当数据包到达时，接收端可以使用readDatagram方法来读取数据包，然后进行组合操作，最终得到完整的数据内容。 总的来说，QT提供了丰富的网络通信模块和接口，可以方便地实现UDP数据的分包和组包操作。开发者可以根据自己的实际需求，灵活运用QT的网络通信功能，来完成对UDP数据的分包组包操作。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值