SocketInputStream 分析_socketinputstream 源码-优快云博客

本文介绍了一种基于环形缓冲区的拆包方法，利用$-$作为包间分隔符，实现高效的数据包读取。适用于网络通信中大量小数据包的处理。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

// //文件名称： SocketInputStream.h //功能描述：消息数据的接收缓存，提供数据的接收和格式化读取功能 // // // #ifndef __SOCKETINPUTSTREAM_H__ #define __SOCKETINPUTSTREAM_H__ #include "BaseType.h" #include "Socket.h" //初始化的接收缓存长度 #define DEFAULTSOCKETINPUTBUFFERSIZE 64*1024 //最大可以允许的缓存长度，如果超过此数值，则断开连接 #define DISCONNECTSOCKETINPUTSIZE 96*1024 class Packet ; class SocketInputStream { public : SocketInputStream( Socket* sock, UINT BufferSize = DEFAULTSOCKETINPUTBUFFERSIZE, UINT MaxBufferSize = DISCONNECTSOCKETINPUTSIZE ) ; virtual ~SocketInputStream( ) ; public : UINT Read( CHAR* buf, UINT len ) ; BOOL ReadPacket( Packet* p ) ; BOOL Peek( CHAR* buf, UINT len ) ; BOOL Find( CHAR* buf ) ; BOOL Skip( UINT len ) ; UINT Fill( ) ; UINT Fill_RAW( ) ; VOID Initsize( ) ; BOOL Resize( INT size ) ; UINT Capacity( )const { return m_BufferLen; } UINT Length( )const ; UINT Size( )const { return Length(); } BOOL IsEmpty( )const { return m_Head==m_Tail; } VOID CleanUp( ) ; UINT GetHead(){return m_Head;} UINT GetTail(){return m_Tail;} UINT GetBuffLen(){return m_BufferLen;} CHAR* GetBuff(){return m_Buffer;} private : Socket* m_pSocket ; CHAR* m_Buffer ; UINT m_BufferLen ; UINT m_MaxBufferLen ; UINT m_Head ; UINT m_Tail ; }; #endif

#include "stdafx.h" #include "SocketInputStream.h" #include "Packet.h" SocketInputStream::SocketInputStream( Socket* sock, UINT BufferLen, UINT MaxBufferLen ) { __ENTER_FUNCTION_FOXNET m_pSocket = sock ; m_BufferLen = BufferLen ; m_MaxBufferLen = MaxBufferLen ; // Assert( m_pSocket != NULL ); // Assert( m_BufferLen > 0 ); m_Head = 0 ; m_Tail = 0 ; m_Buffer = new CHAR[ m_BufferLen ]; // Assert( m_Buffer ) ; memset( m_Buffer, 0, m_BufferLen ) ; __LEAVE_FUNCTION_FOXNET } SocketInputStream::~SocketInputStream( ) { __ENTER_FUNCTION_FOXNET SAFE_DELETE_ARRAY(m_Buffer); __LEAVE_FUNCTION_FOXNET } UINT SocketInputStream::Length( )const { __ENTER_FUNCTION_FOXNET if( m_Head<m_Tail ) return m_Tail-m_Head; else if( m_Head>m_Tail ) return m_BufferLen-m_Head+m_Tail ; return 0 ; __LEAVE_FUNCTION_FOXNET return 0 ; } //返回0表示没有读到数据 UINT SocketInputStream::Read( CHAR* buf, UINT len ) { __ENTER_FUNCTION_FOXNET // Assert( buf != NULL ); if ( len == 0 ) return 0 ; if ( len > Length() ) return 0 ; //读指针位于写指针之前，直接从读的位置开始，读取Len长度的数据 if ( m_Head < m_Tail ) { memcpy( buf, &m_Buffer[m_Head], len ) ; } //读指针位于写指针之后 else { //计算读指针到缓冲区尾部还有多少数据可读 UINT rightLen = m_BufferLen-m_Head ; //如果有足够的数据可读 if( len<=rightLen ) { memcpy( buf, &m_Buffer[m_Head], len ) ; } //没有足够的数据可读，则先读取读指针到缓冲区尾部的数据，再从缓冲区头开始读未完的数据 else { memcpy( buf, &m_Buffer[m_Head], rightLen ) ; memcpy( &buf[rightLen], m_Buffer, len-rightLen ) ; } } //移动读的位置 m_Head = (m_Head+len)%m_BufferLen ; return len ; __LEAVE_FUNCTION_FOXNET return 0 ; } BOOL SocketInputStream::ReadPacket( Packet* pPacket ) { __ENTER_FUNCTION_FOXNET BOOL ret ; //读取8个字节的包头长度 ret = Skip( PACKET_HEADER_SIZE ) ; if( !ret ) return FALSE ; //读取包的内容 return pPacket->Read( *this ) ; __LEAVE_FUNCTION_FOXNET return FALSE ; } //读取数据，但不移动读指针 BOOL SocketInputStream::Peek( CHAR* buf, UINT len ) { __ENTER_FUNCTION_FOXNET // Assert( buf!=NULL ) ; if( len==0 ) return FALSE ; if( len>Length() ) return FALSE ; if( m_Head<m_Tail ) { memcpy( buf , &m_Buffer[m_Head] , len ); } else { UINT rightLen = m_BufferLen-m_Head ; if( len<=rightLen ) { memcpy( &buf[0], &m_Buffer[m_Head], len ) ; } else { memcpy( &buf[0], &m_Buffer[m_Head], rightLen ) ; memcpy( &buf[rightLen], &m_Buffer[0], len-rightLen ) ; } } return TRUE ; __LEAVE_FUNCTION_FOXNET return FALSE ; } BOOL SocketInputStream::Find( CHAR* buf ) { __ENTER_FUNCTION_FOXNET // Assert( buf!=NULL ) ; BOOL IsFind = FALSE; //可读数据(到缓冲区尾部)大于 "$-$" 的长度 while ( Length() > PACK_COMPART_SIZE ) { if( m_Head<m_Tail ) { memcpy( buf , &m_Buffer[m_Head] , PACK_COMPART_SIZE ); } else { UINT rightLen = m_BufferLen-m_Head ; if( PACK_COMPART_SIZE<=rightLen ) { memcpy( &buf[0], &m_Buffer[m_Head], PACK_COMPART_SIZE ) ; } else { //否则，先从读指针到尾部为止的数据，再从缓冲区头开始读 memcpy( &buf[0], &m_Buffer[m_Head], rightLen ) ; memcpy( &buf[rightLen], &m_Buffer[0], PACK_COMPART_SIZE-rightLen ) ; } } //在字符串中查找 $-$，如果未找到，读指针向后移动一个位置 //在此处需要便利整个缓冲区直到找到"$-$"为止,找到的话，将读指针指向包分隔符的下一个位置，即数据内容的位置 if (strstr(buf, PACK_COMPART) == NULL){ m_Head++; if (m_Head >= m_BufferLen){ m_Head -= m_BufferLen; } continue; } else{ IsFind = TRUE; break; } } if (!IsFind){ return FALSE; } m_Head += (UINT)PACK_COMPART_SIZE; if (m_Head >= m_BufferLen){ m_Head -= m_BufferLen; } return TRUE ; __LEAVE_FUNCTION_FOXNET return FALSE ; } BOOL SocketInputStream::Skip( UINT len ) { __ENTER_FUNCTION_FOXNET if( len == 0 ) return FALSE ; if( len>Length( ) ) return FALSE ; m_Head = (m_Head+len)%m_BufferLen ; return TRUE ; __LEAVE_FUNCTION_FOXNET return FALSE ; } VOID SocketInputStream::Initsize( ) { m_Head = 0 ; m_Tail = 0 ; SAFE_DELETE_ARRAY( m_Buffer ) ; m_Buffer = new CHAR[DEFAULTSOCKETINPUTBUFFERSIZE] ; // Assert(m_Buffer) ; m_BufferLen = DEFAULTSOCKETINPUTBUFFERSIZE ; memset( m_Buffer, 0, m_BufferLen ) ; } UINT SocketInputStream::Fill( ) { __ENTER_FUNCTION_FOXNET UINT nFilled = 0 ; UINT nReceived = 0 ; UINT nFree = 0 ; //读指针 <= 写指针,即缓冲区的读数据的位置在前，写数据的位置在后，还未追尾 if ( m_Head <= m_Tail ) { //如果还没有开始读数据 if ( m_Head == 0 ) { // // H T LEN=10 // 0123456789 // abcd...... // nReceived = 0 ; //可写字节数 nFree = m_BufferLen-m_Tail-1 ; if( nFree != 0 ) { //根据可写的长度来接收数据，不会导致缓冲区溢出，也可能套接字中并没有nFree大小的数据可读，nReceived是实际读到的数据大小 nReceived = m_pSocket->receive( &m_Buffer[m_Tail] , nFree ); if (nReceived==SOCKET_ERROR_WOULDBLOCK) return 0 ; if (nReceived==SOCKET_ERROR) return SOCKET_ERROR-1 ; if (nReceived==0) return SOCKET_ERROR-2 ; //写指针向后移动nReceived的字节数 m_Tail += nReceived; //填充字节数 nFilled += nReceived; } //如果接收的数据刚好等于缓冲可写的数据长度 if( nReceived == nFree ) { //计算套接字中还有多少可读数据 UINT available = m_pSocket->available(); if ( available > 0 ) { //如果套接字还有可读的数据,并且现有的缓冲区长度加上将要接收的数据长度大于最大缓冲区长度（大于此长度即断开连接）,重新初始化缓冲区 if( (m_BufferLen+available+1)>m_MaxBufferLen ) { Initsize( ) ; return SOCKET_ERROR-3 ; } //否则的话，重新分配缓冲区(m_BufferLen+available+1) if( !Resize( available+1 ) ) return 0 ; //接收套接字中剩余的数据 nReceived = m_pSocket->receive( &m_Buffer[m_Tail] , available ); if (nReceived==SOCKET_ERROR_WOULDBLOCK) return 0 ; if (nReceived==SOCKET_ERROR) return SOCKET_ERROR-4 ; if (nReceived==0) return SOCKET_ERROR-5; m_Tail += nReceived; nFilled += nReceived; } } } //读指针不为0，已读部分数据 else { // // H T LEN=10 // 0123456789 // ...abcd... // //缓冲区还有多少可写数据的空间，仅仅计算到缓冲区尾部为止 nFree = m_BufferLen-m_Tail ; //从套接字中读取nFree大小的数据， nReceived = m_pSocket->receive( &m_Buffer[m_Tail], nFree ); if( nReceived==SOCKET_ERROR_WOULDBLOCK ) return 0 ; if( nReceived==SOCKET_ERROR ) return SOCKET_ERROR-6 ; if( nReceived==0 ) return SOCKET_ERROR-7 ; //写指针向后移动nReceived个位置，当遇到缓冲区结尾的时候，转到缓冲区头，此时的情况是刚好数据写到缓冲区尾部了 //^_^考虑：如果超出的数据大小大于读指针的位置？或者这个跟拆包时的设计有关，拆包的时候是以某个标记来分隔包的，所以允许存在丢包的情况，这样的情况也不会太多。 m_Tail = (m_Tail+nReceived)%m_BufferLen ; nFilled += nReceived ; //如果套接字的数据未读取完 if( nReceived==nFree ) { // Assert( m_Tail == 0 ); nReceived = 0 ; //到读指针所在的位置还有多少数据可写 nFree = m_Head-1 ; if( nFree!=0 ) { nReceived = m_pSocket->receive( &m_Buffer[0] , nFree ); if( nReceived==SOCKET_ERROR_WOULDBLOCK ) return 0 ; if( nReceived==SOCKET_ERROR ) return SOCKET_ERROR -8; if( nReceived==0 ) return SOCKET_ERROR-9 ; m_Tail += nReceived; nFilled += nReceived; } //如果此时套接字还有数据未读完 if( nReceived==nFree ) { //计算还有多少数据可读 UINT available = m_pSocket->available(); if ( available > 0 ) { if( (m_BufferLen+available+1)>m_MaxBufferLen ) { Initsize( ) ; return SOCKET_ERROR-10 ; } if( !Resize( available+1 ) ) return 0 ; nReceived = m_pSocket->receive( &m_Buffer[m_Tail] , available ); if (nReceived==SOCKET_ERROR_WOULDBLOCK) return 0 ; if (nReceived==SOCKET_ERROR) return SOCKET_ERROR-11 ; if (nReceived==0) return SOCKET_ERROR-12; m_Tail += nReceived; nFilled += nReceived; } } } } } //读指针 > 写指针,即缓冲区的读数据的位置在后，写数据的位置在前，还未追尾 else { // // T H LEN=10 // 0123456789 // abcd...efg // nReceived = 0 ; //首先计算读指针到缓冲区尾部还有多少可写的空间 nFree = m_Head-m_Tail-1 ; if( nFree!=0 ) { nReceived = m_pSocket->receive( &m_Buffer[m_Tail], nFree ) ; if( nReceived==SOCKET_ERROR_WOULDBLOCK ) return 0 ; if( nReceived==SOCKET_ERROR ) return SOCKET_ERROR-13 ; if( nReceived==0 ) return SOCKET_ERROR-14 ; m_Tail += nReceived ; nFilled += nReceived ; } //如果套接字的数据还未读完 if( nReceived==nFree ) { //计算套接字还有多少数据可读 UINT available = m_pSocket->available( ) ; if ( available>0 ) { if( (m_BufferLen+available+1)>m_MaxBufferLen ) { Initsize( ) ; return SOCKET_ERROR-15 ; } //直接在缓冲区尾部扩充，重新分配内存,保证读完套接字所有的数据 if( !Resize( available+1 ) ) return 0 ; nReceived = m_pSocket->receive( &m_Buffer[m_Tail], available ) ; if( nReceived==SOCKET_ERROR_WOULDBLOCK ) return 0 ; if( nReceived==SOCKET_ERROR ) return SOCKET_ERROR-16 ; if( nReceived==0 ) return SOCKET_ERROR-17 ; m_Tail += nReceived ; nFilled += nReceived ; } } } return nFilled ; __LEAVE_FUNCTION_FOXNET return 0 ; } BOOL SocketInputStream::Resize( INT size ) { __ENTER_FUNCTION_FOXNET // Assert( size != 0 ) ; size = max(size, (int)(m_BufferLen>>1)); UINT newBufferLen = m_BufferLen + size; UINT len = Length(); if ( size < 0 ) { if ( newBufferLen < 0 || newBufferLen < len ) return FALSE ; } CHAR * newBuffer = new CHAR[ newBufferLen ]; // Assert( newBuffer ) ; //仅仅拷贝未读的数据 if ( m_Head < m_Tail ) { memcpy( newBuffer , &m_Buffer[m_Head] , m_Tail - m_Head ); } //此情况是读指针已读取部分数据，写指针已经写完一圈，又从头开始写，但还没有追尾 //先将读指针后到缓冲区尾部未读的数据拷贝，然后再拷贝缓冲区头部未读的数据 else if ( m_Head > m_Tail ) { memcpy( newBuffer , &m_Buffer[m_Head] , m_BufferLen - m_Head ); memcpy( &newBuffer[ m_BufferLen - m_Head ] , m_Buffer , m_Tail ); } delete [] m_Buffer ; m_Buffer = newBuffer ; m_BufferLen = newBufferLen ; m_Head = 0 ; m_Tail = len ; return TRUE ; __LEAVE_FUNCTION_FOXNET return FALSE ; } VOID SocketInputStream::CleanUp( ) { __ENTER_FUNCTION_FOXNET m_Head = 0 ; m_Tail = 0 ; __LEAVE_FUNCTION_FOXNET }

网络层的拆包使用环形缓冲区，包由包头+内容组成，每个包之间使用"$-$"做为分隔符，包头包括 PACKET ID，消息序列号，消息长度组成

在实际设计中，每个玩家关联一个套接字，一个输入缓冲区，一个输入缓冲区，通过BOOL ReadPacket( Packet* p ) ; 这个接口，从输入缓冲区SocketInputStream中读取数据，先取包头，然后取包内容，通过在缓冲区中查找"$-$"来分隔每一个数据包。

消息都是以Packet为基类，通过虚函数机制，找到对应的数据包，读取数据。

值得一提的是，在使用环形缓冲接收数据包的时候，可以根据套接字读取相关联.首先计算环形缓冲区中还有多少可写数据空间，从套接字中取多少数据并写到缓冲区中；然后判断套接字中数据是否已经读完，然后读取剩余数据，并对缓冲区大小进行调节。

另外，数据包发送前也有次打包的过程，这样适合于大量小数据包发送，这个由SocketOutputStream来处理。