更新记录

• 我们从经典的计算机科学丛书上阅到的知识，都说：TCP协议是没有消息边界的。但是这个要怎么理解呢？在我没有接触底层的套接字相关逻辑时。我对此也没有特别的了解。直到阅读了套接字的相关逻辑源码，才对此有了一定的了解
• TCP的发包和我们业务层所发出的协议数据是不一定吻合的。也就是说，我们发的数据库可能会被分拆成不同的包。然后再和别的协议（这里当然是只发往同一个端口）的数据封装同一个TCP包体。
• 因此。对于我们业务网络层而言，我们需要在一个TCP包体里面区分出不同的实际业务包。
• 目前业界常用的做法有三个，可参考TCP消息边界处理
• 但是最常使用的是第二种做法。在我们发送的协议数据里面。协议头带上协议包体的长度，特定的协议号。以及特殊的用于标。协议头的数据。这些协议数据都会统一。作为TCP协议的包体数据。在网络上进行传输
• 第一种方案和第三种方案的缺点都比较大。
• 第二种方案，有一些好处。
  • 我们的应用程序中，app和server的数据交互是非常多，往往需要不同的协议号（也叫做命令字）去区分不同的业务场景，比如某几条协议负责登录，某条协议负责用户的个人资料等等。通过在业务协议头上，填充协议号，那么在客户端收到TCP回包，解析了协议头时，就可以往不同的业务上层抛出通知，处理起来就非常方便，水到渠成。
  • 其次，协议头里面，还可以塞入其他有需要塞入的数据。比如，客户端版本，登录的用户ID，客户端使用的语言类型等，总之，使得我们自定义的协议头的长度是固定的即可。
• 一个典型的协议头设计如下：

粘包

• 介绍上了上述方案的选择，就要面对这个方案面临的一个问题
• 我们之前说的，我们发送的数据有三个包： [1,2,3] [4,5,6] [7,8,9,10]，但是底层的TCP协议发出去的时候不一定是 [1,2,3] [4,5,6] [7,8,9,10]。有可能是 [1,2,3,4] [,5,6,7] [8,9,10]等，随机的一种组合。
• 因此，我们的app应用层就需要去识别这些数据，正确地解成我们自定义的协议数据。
• 下面结合实际代码，来演示从套接字中接收数据的整个过程。

void CMyWinTCPSocket::OnReceive(int nErrorCode)
{
    static unsigned int nHeaderLen = sizeof(PROTOCOL_HEADER); //自定义协议，固定长度的头部
    m_nLastErrorCode = nErrorCode;  //记录错误码
    if (nErrorCode != 0)
    {
        //错误码不为0，此处需要打印日志记录
    }

    //记录本次套接字被激活的时间
    m_uSocketActiveTime = ::GetTickCount();

    DWORD nBytes = 0;
    if (!IOCtl(FIONREAD, &nBytes) || nBytes == 0) //FIONREAD返回套接字上排队的第一个数据报大小
    {
    m_nLastErrorCode = WSAGetLastError();
        //打印该错误码，由于读取套接字上的数据失败，直接返回。
    return;
    }
    //此时套接字中可获取的数据有nBytes个字节

    //开始读取数据
    char *pReceiveBuffer = new char[nBytes]; //有多少读多少，一次性读完
    int nRead = CAsyncSocketEx::Receive(pReceiveBuffer, nBytes);    //nRead是实际读取到的数据
    if (nRead <= 0) //出现异常，需要退出
    {
        //释放new出来的char数组
        delete_array(pReceiveBuffer);
        return;
    }

    int nCurrentOffset = 0;     //记录读取本次的套接字数据的offset（偏移量）
    int nLeftSize = nRead;      //本次套接字返回的数据，剩下的未读取的字节数
    char *pOffsetBuffer = pReceiveBuffer;
    std::vector<tagRecvPack> vecRecvPacks;  //tagRecvPack表示一个收到的应用层的包，从成员变量offset来判断当前获取的字节数

    do 
    {
        //注意：如果上次调用onReceive时，仍然存有数据（即不完整的包），此时就不会重新解析头部。（也就是，所谓的粘包操作）
    if (m_RecvPack.pHeadBuffer == NULL) //从头开始读取头部（一个新的包）
    {
        m_RecvPack.pHeadBuffer = new char[nHeaderLen];  //记录自定义协议头的数据
        ZeroMemory(m_RecvPack.pHeadBuffer, nHeaderLen);
        m_RecvPack.uHeadOffset = 0;
        m_RecvPack.uHeadTotal = nHeaderLen;     //记录包头的长度

        //保护逻辑
        MF_Delete1D(m_RecvPack.pBodyBuffer);    //记录包体的实际数据
        m_RecvPack.pBodyBuffer = NULL;
        m_RecvPack.uBodyOffset = 0;
    }

        //判断上次调用onReceive的数据是否已经读取完头部，
    if (m_RecvPack.uHeadOffset < nHeaderLen)
    {
            //读取头部，有两种情况：
            //a. 上次的onReceive没有读取完的（也就是要把上次onReceive收到的数据，和这次收到的数据粘起来，搞成一个新的包传给上层）
            //b. 本次读取套接字buffer时，新的一个包，重新解析头部的情况。

            //---------- 1. 读数据，把这个包的头部读取完---------------------//
        char *p = m_RecvPack.pHeadBuffer + m_RecvPack.uHeadOffset;
        int len = std::min<int>((nHeaderLen - m_RecvPack.uHeadOffset), nLeftSize);
        memcpy(p, pOffsetBuffer, len);
        nCurrentOffset += len;
        pOffsetBuffer = pReceiveBuffer + nCurrentOffset;
        nLeftSize -= len;
        m_RecvPack.uHeadOffset += len;
            //---------- 1. 读数据，把这个包的头部读取完---------------------//
            if (m_RecvPack.uHeadOffset == nHeaderLen)
        {
                //-----------2. 头部读完，开始做准备或者容错之类的工作-----------//
                assert(m_RecvPack.pBodyBuffer != NULL);
                PROTOCOL_HEADER *pHeader = (PROTOCOL_HEADER *)m_RecvPack.pHeadBuffer;
            int nBodyLength = ntohl(pHeader->dwBodyLength);     //这就是传说中的，协议头上带上包体数据的长度

                //版本号，协议号等其他字段（可根据业务自行扩展，但后续不允许改动，否则老版本不兼容）
            BYTE chVersion = pHeader->chVersion;                
            WORD wClientVersion = ntohs(pHeader->wClientVersion);
        WORD wCmdID = ntohs(pHeader->wCmdID);
        DWORD dwSerialNO = ntohl(pHeader->dwSerialNO);

        //简单的包校验
        if (chVersion != TCP_PROTOCOL_VERSION ||
            wClientVersion != m_wClientVersion ||
            pHeader->chMagicCode[0] != TCP_PROTOCOL_MAGIC_CODE1 ||
            pHeader->chMagicCode[1] != TCP_PROTOCOL_MAGIC_CODE2)
        {
            //处理包校验错误的情况
            Close(false); //出错，直接关闭socket
            break;
        }

        m_RecvPack.uBodyTotal = nBodyLength;

        if (m_RecvPack.uBodyTotal == 0) //一个空包，以前的逻辑是直接抛弃的，现在空包也要
        {
                    //处理空包的情况
        }
        //包体过大，应该是数据错乱了，剩下的包已经不知道怎么解析了，只能断开
        else if (m_RecvPack.uBodyTotal > TCP_PROTOCOL_PACKET_MAX_LENGTH)
        {
            //处理出错的情况
            m_RecvPack.reset();
            Close(false); //直接关闭socket算了，要不后面包也是乱的了
            break;
        }
                //-----------2. 头部读完，开始做准备或者容错之类的工作-----------//

                //-----------3. 创建好干净的包体，用以存储包体数据-----------//
        if (m_RecvPack.uBodyTotal > 0)
        {
            MF_Delete1D(m_RecvPack.pBodyBuffer);
            m_RecvPack.pBodyBuffer = new char[m_RecvPack.uBodyTotal];
            ZeroMemory(m_RecvPack.pBodyBuffer, m_RecvPack.uBodyTotal);
            m_RecvPack.uBodyOffset = 0;
        }
                //-----------3. 创建好干净的包体，用以存储包体数据-----------//
        }
        }

    //开始读取包体
    else if (m_RecvPack.pHeadBuffer && m_RecvPack.uHeadOffset == nHeaderLen)
    {
             //---4.根据协议头带上的包体长度，直接解析包体,如果套接字buffer不够长，要先存起来，等待下次onReceive调用时再粘包---//
         if (m_RecvPack.uBodyTotal > 0 && m_RecvPack.uBodyOffset < m_RecvPack.uBodyTotal)
         {
        char *p = m_RecvPack.pBodyBuffer + m_RecvPack.uBodyOffset;
        int len = std::max<int>(0, (std::min<int>((m_RecvPack.uBodyTotal - m_RecvPack.uBodyOffset), nLeftSize)));
        assert(len != 0); 
        memcpy(p, pOffsetBuffer, len);
        nCurrentOffset += len;
        pOffsetBuffer = pReceiveBuffer + nCurrentOffset;
        nLeftSize -= len;
        m_RecvPack.uBodyOffset += len;
        }
        if (m_RecvPack.uBodyOffset == m_RecvPack.uBodyTotal && m_RecvPack.pBodyBuffer != NULL) //数据读取完成
        {
                //本次套接字buffer解析出了一个包，用容器记录下来，后续一起抛给上层
        vecRecvPacks.push_back(m_RecvPack);
                //这个包解析晚了，清空这个成员变量，用以解析下一个包
        m_RecvPack.reset();
        }
            //---4.根据协议头带上的包体长度，直接解析包体,如果套接字buffer不够长，要先存起来，等待下次onReceive调用时再粘包---//
        }
    else
    {
        assert;
    }
    } while (nLeftSize > 0);

    //还回数据
    MF_Delete1D(pReceiveBuffer);

    //本次解析出来的包，每一个依次往上层抛出回调
    auto uConnectOrderSession = m_uConnectOrderSession;
    for (auto it : vecRecvPacks)
    {
    if (it.pHeadBuffer == NULL)
    {
        continue;
    }

    if (uConnectOrderSession != m_uConnectOrderSession)
    {
            //出错了
        OnErrorPack(it);
            assert;
        break;
    }

    if (it.uBodyTotal == 0)
    {
            //收到了空包
        OnRecvEmptyPack(it);
    }
    else
    {
            //收到了一个完整的包，通知对应的业务上层
        OnRecvPack(it);
    }
    }
}