最简单的TCP网络封包解包

struct NetPacket
{
包头;
数据;
};

struct NetPacketHeader
{
操作码;
包长度;
};

#include "stdafx.h"
#include "TCPServer.h"

TCPServer::TCPServer()
: mServerSocket(INVALID_SOCKET)
{
    // 创建套接字
    mServerSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    if (mServerSocket == INVALID_SOCKET)
    {
        std::cout << "创建套接字失败!" << std::endl;
        return;
    }

    // 填充服务器的IP和端口号
    mServerAddr.sin_family        = AF_INET;
    mServerAddr.sin_addr.s_addr    = INADDR_ANY;
    mServerAddr.sin_port        = htons((u_short)SERVER_PORT);

    // 绑定IP和端口
    if ( ::bind(mServerSocket, (sockaddr*)&mServerAddr, sizeof(mServerAddr)) == SOCKET_ERROR)
    {
        std::cout << "绑定IP和端口失败!" << std::endl;
        return;
    }

    // 监听客户端请求,最大同时连接数设置为10.
    if ( ::listen(mServerSocket, SOMAXCONN) == SOCKET_ERROR)
    {
        std::cout << "监听端口失败!" << std::endl;
        return;
    }

    std::cout << "启动TCP服务器成功!" << std::endl;
}

TCPServer::~TCPServer()
{
    ::closesocket(mServerSocket);
    std::cout << "关闭TCP服务器成功!" << std::endl;
}

void TCPServer::run()
{
    // 接收客户端的连接
    acceptClient();

    int nCount = 0;
    for (;;)
    {
        if (mAcceptSocket == INVALID_SOCKET) 
        {
            std::cout << "客户端主动断开了连接！" << std::endl;
            break;
        }

        // 发送数据包
        NetPacket_Test1 msg;
        msg.nIndex = nCount;
        strncpy(msg.arrMessage, "[1]你好[2]你好[3]你好", sizeof(msg.arrMessage) );
        bool bRet = SendData(NET_TEST1, (const char*)&msg, sizeof(msg));
        if (bRet)
        {
            std::cout << "发送数据成功！" << std::endl;
        }
        else
        {
            std::cout << "发送数据失败！" << std::endl;
            break;
        }

        ++nCount;
    }
}

void TCPServer::closeClient()
{
    // 判断套接字是否有效
    if (mAcceptSocket == INVALID_SOCKET) return;

    // 关闭客户端套接字
    ::closesocket(mAcceptSocket);
    std::cout << "客户端套接字已关闭!" << std::endl;
}

void TCPServer::acceptClient()
{
    // 以阻塞方式,等待接收客户端连接
    int nAcceptAddrLen = sizeof(mAcceptAddr);
    mAcceptSocket = ::accept(mServerSocket, (struct sockaddr*)&mAcceptAddr, &nAcceptAddrLen);
    std::cout << "接受客户端IP:" << inet_ntoa(mAcceptAddr.sin_addr) << std::endl;
}

bool TCPServer::SendData( unsigned  short nOpcode,  const  char* pDataBuffer,  const unsigned  int& nDataSize )
{
    NetPacketHeader* pHead = (NetPacketHeader*) m_cbSendBuf;
    pHead->wOpcode = nOpcode;

    // 数据封包
    if ( (nDataSize > 0) && (pDataBuffer != 0) )
    {
        CopyMemory(pHead+1, pDataBuffer, nDataSize);
    }

    // 发送消息
    const unsigned short nSendSize = nDataSize + sizeof(NetPacketHeader);
    pHead->wDataSize = nSendSize;
    int ret = ::send(mAcceptSocket, m_cbSendBuf, nSendSize, 0);
    return (ret > 0) ? true : false;
}

#include "stdafx.h"
#include "TCPClient.h"


TCPClient::TCPClient()
{
    memset( m_cbRecvBuf, 0, sizeof(m_cbRecvBuf) );
    m_nRecvSize = 0;

    // 创建套接字
    mServerSocket = socket(AF_INET, SOCK_STREAM, IPPROTO_IP);
    if (mServerSocket == INVALID_SOCKET)
    {
        std::cout << "创建套接字失败!" << std::endl;
        return;
    }

    // 填充服务器的IP和端口号
    mServerAddr.sin_family        = AF_INET;
    mServerAddr.sin_addr.s_addr    = inet_addr(SERVER_IP);
    mServerAddr.sin_port        = htons((u_short)SERVER_PORT);

    // 连接到服务器
    if ( ::connect(mServerSocket, (struct sockaddr*)&mServerAddr, sizeof(mServerAddr)))
    {
        ::closesocket(mServerSocket);
        std::cout << "连接服务器失败!" << std::endl;
        return;    
    }
}

TCPClient::~TCPClient()
{
    ::closesocket(mServerSocket);
}

void TCPClient::run()
{
    int nCount = 0;
    for (;;)
    {
        // 接收数据
        int nRecvSize = ::recv(mServerSocket,
            m_cbRecvBuf+m_nRecvSize, 
            sizeof(m_cbRecvBuf)-m_nRecvSize, 0);
        if (nRecvSize <= 0)
        {
            std::cout << "服务器主动断开连接!" << std::endl;
            break;
        }

        // 保存已经接收数据的大小
        m_nRecvSize += nRecvSize;

        // 接收到的数据够不够一个包头的长度
        while (m_nRecvSize >= sizeof(NetPacketHeader))
        {
            // 收够5个包，主动与服务器断开
            if (nCount >= 5)
            {
                ::closesocket(mServerSocket);
                break;
            }

            // 读取包头
            NetPacketHeader* pHead = (NetPacketHeader*) (m_cbRecvBuf);
            const unsigned short nPacketSize = pHead->wDataSize;

            // 判断是否已接收到足够一个完整包的数据
            if (m_nRecvSize < nPacketSize)
            {
                // 还不够拼凑出一个完整包
                break;
            }

            // 拷贝到数据缓存
            CopyMemory(m_cbDataBuf, m_cbRecvBuf, nPacketSize);

            // 从接收缓存移除
            MoveMemory(m_cbRecvBuf, m_cbRecvBuf+nPacketSize, m_nRecvSize);
            m_nRecvSize -= nPacketSize;

            // 解密数据，以下省略一万字
            // 

            // 分派数据包，让应用层进行逻辑处理
            pHead = (NetPacketHeader*) (m_cbDataBuf);
            const unsigned short nDataSize = nPacketSize - (unsigned short)sizeof(NetPacketHeader);
            OnNetMessage(pHead->wOpcode, m_cbDataBuf+sizeof(NetPacketHeader), nDataSize);

            ++nCount;
        }
    }

    std::cout << "已经和服务器断开连接!" << std::endl;
}

bool TCPClient::OnNetMessage(  const unsigned  short& nOpcode, 
                              const  char* pDataBuffer, unsigned  short nDataSize )
{
    switch (nOpcode)
    {
    case NET_TEST1:
        {
            NetPacket_Test1* pMsg = (NetPacket_Test1*) pDataBuffer;
            return OnNetPacket(pMsg);
        }
        break;

    default:
        {
            std::cout << "收取到未知网络数据包:" << nOpcode << std::endl;
            return false;
        }
        break;
    }
}

bool TCPClient::OnNetPacket( NetPacket_Test1* pMsg )
{
    std::cout << "索引：" << pMsg->nIndex << "  字符串：" << pMsg->arrMessage << std::endl;
    return true;
}