手把手教你实现自定义的应用层协议

最新推荐文章于 2024-07-27 10:02:26 发布
最新推荐文章于 2024-07-27 10:02:26 发布
阅读量1.6k 收藏 1
点赞数
分类专栏： 网络协议 网络编程

1.简述

  • 互联网上充斥着各种各样的网络服务，在对外提供网络服务时，服务端和客户端需要遵循同一套数据通讯协议，才能正常的进行通讯；就好像你跟台湾人沟通用闽南语，跟广东人沟通就用粤语一样。

  • 实现自己的应用功能时，已知的知名协议（http，smtp，ftp等）在安全性、可扩展性等方面不能满足需求，从而需要设计并实现自己的应用层协议。

2.协议分类

2.1按编码方式

  • 二进制协议
    比如网络通信运输层中的tcp协议。

  • 明文的文本协议
    比如应用层的http、redis协议。

  • 混合协议（二进制+明文）
    比如苹果公司早期的APNs推送协议。

2.2按协议边界

  • 固定边界协议
    能够明确得知一个协议报文的长度，这样的协议易于解析，比如tcp协议。

  • 模糊边界协议
    无法明确得知一个协议报文的长度，这样的协议解析较为复杂，通常需要通过某些特定的字节来界定报文是否结束，比如http协议。

3.协议优劣的基本评判标准

  • 高效的
    快速的打包解包减少对cpu的占用，高数据压缩率降低对网络带宽的占用。

  • 简单的
    易于人的理解、程序的解析。

  • 易于扩展的
    对可预知的变更，有足够的弹性用于扩展。

  • 容易兼容的

    • 向前兼容，对于旧协议发出的报文，能使用新协议进行解析，只是新协议支持的新功能不能使用。

    • 向后兼容，对于新协议发出的报文，能使用旧协议进行解析，只是新协议支持的新功能不能使用。

4.自定义应用层协议的优缺点

4.1优点

  • 非知名协议，数据通信更安全，黑客如果要分析协议的漏洞就必须先破译你的通讯协议。

  • 扩展性更好，可以根据业务需求和发展扩展自己的协议，而已知的知名协议不好扩展。

4.2缺点

  • 设计难度高，协议需要易扩展，最好能向后向前兼容。

  • 实现繁琐，需要自己实现序列化和反序列化。

5.动手前的预备知识

5.1大小端

计算机系统在存储数据时起始地址是高地址还是低地址。

  • 大端
    从高地址开始存储。

  • 小端
    从低地址开始存储。

  • 图解

  • 判断
    这里以c/c++语言代码为例，使用了c语言中联合体的特性。

#include <stdint.h>
#include <iostream>
using namespace std;

bool bigCheck()
{
    union Check
    {
        char a;
        uint32_t data;
    };
    
    Check c;
    c.data = 1;
    
    if (1 == c.a)
    {
        return false;
    }
    
    return true;
}

int main()
{
    if (bigCheck())
    {
        cout << "big" << endl;
    }
    else
    {
        cout << "small" << endl;
    }
    return 0;
}

5.2网络字节序

顾名思义就是数据在网络传送的字节流中的起始地址的高低，为了避免在网络通信中引入其他复杂性，网络字节序统一是大端的。

5.3本地字节序

本地操作系统的大小端，不同操作系统可能采用不同的字节序。

5.4内存对象与布局

任何变量，不管是堆变量还是栈变量都对应着操作系统中的一块内存，由于内存对齐的要求程序中的变量并不是紧凑存储的，例如一个c语言的结构体Test在内存中的布局可能如下图所示。

struct Test
{
    char a;
    char b;
    int32_t c;
};

5.5序列化与反序列化

  • 将计算机语言中的内存对象转换为网络字节流，例如把c语言中的结构体Test转化成uint8_t data[6]字节流。

  • 将网络字节流转换为计算机语言中的内存对象，例如把uint8_t data[6]字节流转化成c语言中的结构体Test。

6.一个例子

6.1 协议设计

本协议采用固定边界+混合编码策略。

  • 协议头
    8字节的定长协议头。支持版本号，基于魔数的快速校验，不同服务的复用。定长协议头使协议易于解析且高效。

  • 协议体
    变长json作为协议体。json使用明文文本编码，可读性强、易于扩展、前后兼容、通用的编解码算法。json协议体为协议提供了良好的扩展性和兼容性。

  • 协议可视化图

6.2 协议实现

talk is easy，just code it，使用c/c++语言来实现。

6.2.1c/c++语言实现

  • 使用结构体MyProtoHead来存储协议头

/*
    协议头
 */
struct MyProtoHead
{
    uint8_t version;    //协议版本号
    uint8_t magic;      //协议魔数
    uint16_t server;    //协议复用的服务号，标识协议之上的不同服务
    uint32_t len;       //协议长度（协议头长度+变长json协议体长度）
};
/*
    协议消息体
 */
struct MyProtoMsg
{
    MyProtoHead head;   //协议头
    Json::Value body;   //协议体
};

  • 打包类

/*
    MyProto打包类
 */
class MyProtoEnCode
{
public:
    //协议消息体打包函数
    uint8_t * encode(MyProtoMsg * pMsg, uint32_t & len);
private:
    //协议头打包函数
    void headEncode(uint8_t * pData, MyProtoMsg * pMsg);
};

  • 解包类

typedef enum MyProtoParserStatus
{
    ON_PARSER_INIT = 0,
    ON_PARSER_HAED = 1,
    ON_PARSER_BODY = 2,
}MyProtoParserStatus;
/*
    MyProto解包类
 */
class MyProtoDeCode
{
public:
    void init();
    void clear();
    bool parser(void * data, size_t len);
    bool empty();
    MyProtoMsg * front();
    void pop();
private:
    bool parserHead(uint8_t ** curData, uint32_t & curLen, 
        uint32_t & parserLen, bool & parserBreak);
    bool parserBody(uint8_t ** curData, uint32_t & curLen, 
        uint32_t & parserLen, bool & parserBreak);
    
private:
    MyProtoMsg mCurMsg;                     //当前解析中的协议消息体
    queue<MyProtoMsg *> mMsgQ;              //解析好的协议消息队列
    vector<uint8_t> mCurReserved;           //未解析的网络字节流
    MyProtoParserStatus mCurParserStatus;   //当前解析状态
};
6.2.2打包（序列化）
void MyProtoEnCode::headEncode(uint8_t * pData, MyProtoMsg * pMsg)
{
    //设置协议头版本号为1
    *pData = 1; 
    ++pData;

    //设置协议头魔数
    *pData = MY_PROTO_MAGIC;
    ++pData;

    //设置协议服务号，把head.server本地字节序转换为网络字节序
    *(uint16_t *)pData = htons(pMsg->head.server);
    pData += 2;

    //设置协议总长度，把head.len本地字节序转换为网络字节序
    *(uint32_t *)pData = htonl(pMsg->head.len);
}

uint8_t * MyProtoEnCode::encode(MyProtoMsg * pMsg, uint32_t & len)
{
    uint8_t * pData = NULL;
    Json::FastWriter fWriter;
    
    //协议json体序列化
    string bodyStr = fWriter.write(pMsg->body);
    //计算协议消息序列化后的总长度
    len = MY_PROTO_HEAD_SIZE + (uint32_t)bodyStr.size();
    pMsg->head.len = len;
    //申请协议消息序列化需要的空间
    pData = new uint8_t[len];
    //打包协议头
    headEncode(pData, pMsg);
    //打包协议体
    memcpy(pData + MY_PROTO_HEAD_SIZE, bodyStr.data(), bodyStr.size());
    
    return pData;
}
6.2.3解包（反序列化）
bool MyProtoDeCode::parserHead(uint8_t ** curData, uint32_t & curLen, 
    uint32_t & parserLen, bool & parserBreak)
{
    parserBreak = false;
    if (curLen < MY_PROTO_HEAD_SIZE)
    {
        parserBreak = true; //终止解析
        return true;
    }

    uint8_t * pData = *curData;
    //解析版本号
    mCurMsg.head.version = *pData;
    pData++;
    //解析魔数
    mCurMsg.head.magic = *pData;
    pData++;
    //魔数不一致，则返回解析失败
    if (MY_PROTO_MAGIC != mCurMsg.head.magic)
    {
        return false;
    }
    //解析服务号
    mCurMsg.head.server = ntohs(*(uint16_t*)pData);
    pData+=2;
    //解析协议消息体的长度
    mCurMsg.head.len = ntohl(*(uint32_t*)pData);
    //异常大包，则返回解析失败
    if (mCurMsg.head.len > MY_PROTO_MAX_SIZE)
    {
        return false;
    }
    
    //解析指针向前移动MY_PROTO_HEAD_SIZE字节
    (*curData) += MY_PROTO_HEAD_SIZE;
    curLen -= MY_PROTO_HEAD_SIZE;
    parserLen += MY_PROTO_HEAD_SIZE;
    mCurParserStatus = ON_PARSER_HAED;

    return true;
}

bool MyProtoDeCode::parserBody(uint8_t ** curData, uint32_t & curLen, 
    uint32_t & parserLen, bool & parserBreak)
{
    parserBreak = false;
    uint32_t jsonSize = mCurMsg.head.len - MY_PROTO_HEAD_SIZE;
    if (curLen < jsonSize)
    {
        parserBreak = true; //终止解析
        return true;
    }

    Json::Reader reader;    //json解析类
    if (!reader.parse((char *)(*curData), 
        (char *)((*curData) + jsonSize), mCurMsg.body, false))
    {
        return false;
    }

    //解析指针向前移动jsonSize字节
    (*curData) += jsonSize;
    curLen -= jsonSize;
    parserLen += jsonSize;
    mCurParserStatus = ON_PARSER_BODY;

    return true;
}

bool MyProtoDeCode::parser(void * data, size_t len)
{
    if (len <= 0)
    {
        return false;
    }

    uint32_t curLen = 0;
    uint32_t parserLen = 0;
    uint8_t * curData = NULL;
    
    curData = (uint8_t *)data;
    //把当前要解析的网络字节流写入未解析完字节流之后
    while (len--)
    {
        mCurReserved.push_back(*curData);
        ++curData;
    }

    curLen = mCurReserved.size();
    curData = (uint8_t *)&mCurReserved[0];

    //只要还有未解析的网络字节流，就持续解析
    while (curLen > 0)
    {
        bool parserBreak = false;
        //解析协议头
        if (ON_PARSER_INIT == mCurParserStatus ||
            ON_PARSER_BODY == mCurParserStatus)
        {
            if (!parserHead(&curData, curLen, parserLen, parserBreak))
            {
                return false;
            }

            if (parserBreak) break;
        }

        //解析完协议头，解析协议体
        if (ON_PARSER_HAED == mCurParserStatus)
        {
            if (!parserBody(&curData, curLen, parserLen, parserBreak))
            {
                return false;
            }

            if (parserBreak) break;
        }

        if (ON_PARSER_BODY == mCurParserStatus)
        {
            //拷贝解析完的消息体放入队列中
            MyProtoMsg * pMsg = NULL;
            pMsg = new MyProtoMsg;
            *pMsg = mCurMsg;
            mMsgQ.push(pMsg);
        }
    }

    if (parserLen > 0)
    {
        //删除已经被解析的网络字节流
        mCurReserved.erase(mCurReserved.begin(), mCurReserved.begin() + parserLen);
    }

    return true;
}

7.完整源码与测试

code is easy，just run it.

7.1源码

#include <stdint.h>
#include <stdio.h>
#include <queue>
#include <vector>
#include <iostream>
#include <string.h>
#include <json/json.h>
#include <arpa/inet.h>
using namespace std;

const uint8_t MY_PROTO_MAGIC = 88;
const uint32_t MY_PROTO_MAX_SIZE = 10 * 1024 * 1024; //10M
const uint32_t MY_PROTO_HEAD_SIZE = 8;

typedef enum MyProtoParserStatus
{
    ON_PARSER_INIT = 0,
    ON_PARSER_HAED = 1,
    ON_PARSER_BODY = 2,
}MyProtoParserStatus;

/*
    协议头
 */
struct MyProtoHead
{
    uint8_t version;    //协议版本号
    uint8_t magic;      //协议魔数
    uint16_t server;    //协议复用的服务号，标识协议之上的不同服务
    uint32_t len;       //协议长度（协议头长度+变长json协议体长度）
};

/*
    协议消息体
 */
struct MyProtoMsg
{
    MyProtoHead head;   //协议头
    Json::Value body;   //协议体
};

void myProtoMsgPrint(MyProtoMsg & msg)
{
    string jsonStr = "";
    Json::FastWriter fWriter;
    jsonStr = fWriter.write(msg.body);
    
    printf("Head[version=%d,magic=%d,server=%d,len=%d]\n"
        "Body:%s", msg.head.version, msg.head.magic, 
        msg.head.server, msg.head.len, jsonStr.c_str());
}
/*
    MyProto打包类
 */
class MyProtoEnCode
{
public:
    //协议消息体打包函数
    uint8_t * encode(MyProtoMsg * pMsg, uint32_t & len);
private:
    //协议头打包函数
    void headEncode(uint8_t * pData, MyProtoMsg * pMsg);
};

void MyProtoEnCode::headEncode(uint8_t * pData, MyProtoMsg * pMsg)
{
    //设置协议头版本号为1
    *pData = 1; 
    ++pData;

    //设置协议头魔数
    *pData = MY_PROTO_MAGIC;
    ++pData;

    //设置协议服务号，把head.server本地字节序转换为网络字节序
    *(uint16_t *)pData = htons(pMsg->head.server);
    pData += 2;

    //设置协议总长度，把head.len本地字节序转换为网络字节序
    *(uint32_t *)pData = htonl(pMsg->head.len);
}

uint8_t * MyProtoEnCode::encode(MyProtoMsg * pMsg, uint32_t & len)
{
    uint8_t * pData = NULL;
    Json::FastWriter fWriter;
    
    //协议json体序列化
    string bodyStr = fWriter.write(pMsg->body);
    //计算协议消息序列化后的总长度
    len = MY_PROTO_HEAD_SIZE + (uint32_t)bodyStr.size();
    pMsg->head.len = len;
    //申请协议消息序列化需要的空间
    pData = new uint8_t[len];
    //打包协议头
    headEncode(pData, pMsg);
    //打包协议体
    memcpy(pData + MY_PROTO_HEAD_SIZE, bodyStr.data(), bodyStr.size());
    
    return pData;
}

/*
    MyProto解包类
 */
class MyProtoDeCode
{
public:
    void init();
    void clear();
    bool parser(void * data, size_t len);
    bool empty();
    MyProtoMsg * front();
    void pop();
private:
    bool parserHead(uint8_t ** curData, uint32_t & curLen, 
        uint32_t & parserLen, bool & parserBreak);
    bool parserBody(uint8_t ** curData, uint32_t & curLen, 
        uint32_t & parserLen, bool & parserBreak);
    
private:
    MyProtoMsg mCurMsg;                     //当前解析中的协议消息体
    queue<MyProtoMsg *> mMsgQ;              //解析好的协议消息队列
    vector<uint8_t> mCurReserved;           //未解析的网络字节流
    MyProtoParserStatus mCurParserStatus;   //当前解析状态
};

void MyProtoDeCode::init()
{
    mCurParserStatus = ON_PARSER_INIT;
}

void MyProtoDeCode::clear()
{
    MyProtoMsg * pMsg = NULL;
    
    while (!mMsgQ.empty())
    {
        pMsg = mMsgQ.front();
        delete pMsg;
        mMsgQ.pop();
    }
}

bool MyProtoDeCode::parserHead(uint8_t ** curData, uint32_t & curLen, 
    uint32_t & parserLen, bool & parserBreak)
{
    parserBreak = false;
    if (curLen < MY_PROTO_HEAD_SIZE)
    {
        parserBreak = true; //终止解析
        return true;
    }

    uint8_t * pData = *curData;
    //解析版本号
    mCurMsg.head.version = *pData;
    pData++;
    //解析魔数
    mCurMsg.head.magic = *pData;
    pData++;
    //魔数不一致，则返回解析失败
    if (MY_PROTO_MAGIC != mCurMsg.head.magic)
    {
        return false;
    }
    //解析服务号
    mCurMsg.head.server = ntohs(*(uint16_t*)pData);
    pData+=2;
    //解析协议消息体的长度
    mCurMsg.head.len = ntohl(*(uint32_t*)pData);
    //异常大包，则返回解析失败
    if (mCurMsg.head.len > MY_PROTO_MAX_SIZE)
    {
        return false;
    }
    
    //解析指针向前移动MY_PROTO_HEAD_SIZE字节
    (*curData) += MY_PROTO_HEAD_SIZE;
    curLen -= MY_PROTO_HEAD_SIZE;
    parserLen += MY_PROTO_HEAD_SIZE;
    mCurParserStatus = ON_PARSER_HAED;

    return true;
}

bool MyProtoDeCode::parserBody(uint8_t ** curData, uint32_t & curLen, 
    uint32_t & parserLen, bool & parserBreak)
{
    parserBreak = false;
    uint32_t jsonSize = mCurMsg.head.len - MY_PROTO_HEAD_SIZE;
    if (curLen < jsonSize)
    {
        parserBreak = true; //终止解析
        return true;
    }

    Json::Reader reader;    //json解析类
    if (!reader.parse((char *)(*curData), 
        (char *)((*curData) + jsonSize), mCurMsg.body, false))
    {
        return false;
    }

    //解析指针向前移动jsonSize字节
    (*curData) += jsonSize;
    curLen -= jsonSize;
    parserLen += jsonSize;
    mCurParserStatus = ON_PARSER_BODY;

    return true;
}

bool MyProtoDeCode::parser(void * data, size_t len)
{
    if (len <= 0)
    {
        return false;
    }

    uint32_t curLen = 0;
    uint32_t parserLen = 0;
    uint8_t * curData = NULL;
    
    curData = (uint8_t *)data;
    //把当前要解析的网络字节流写入未解析完字节流之后
    while (len--)
    {
        mCurReserved.push_back(*curData);
        ++curData;
    }

    curLen = mCurReserved.size();
    curData = (uint8_t *)&mCurReserved[0];

    //只要还有未解析的网络字节流，就持续解析
    while (curLen > 0)
    {
        bool parserBreak = false;
        //解析协议头
        if (ON_PARSER_INIT == mCurParserStatus ||
            ON_PARSER_BODY == mCurParserStatus)
        {
            if (!parserHead(&curData, curLen, parserLen, parserBreak))
            {
                return false;
            }

            if (parserBreak) break;
        }

        //解析完协议头，解析协议体
        if (ON_PARSER_HAED == mCurParserStatus)
        {
            if (!parserBody(&curData, curLen, parserLen, parserBreak))
            {
                return false;
            }

            if (parserBreak) break;
        }

        if (ON_PARSER_BODY == mCurParserStatus)
        {
            //拷贝解析完的消息体放入队列中
            MyProtoMsg * pMsg = NULL;
            pMsg = new MyProtoMsg;
            *pMsg = mCurMsg;
            mMsgQ.push(pMsg);
        }
    }

    if (parserLen > 0)
    {
        //删除已经被解析的网络字节流
        mCurReserved.erase(mCurReserved.begin(), mCurReserved.begin() + parserLen);
    }

    return true;
}

bool MyProtoDeCode::empty()
{
    return mMsgQ.empty();
}

MyProtoMsg * MyProtoDeCode::front()
{
    MyProtoMsg * pMsg = NULL;
    pMsg = mMsgQ.front();
    return pMsg;
}

void MyProtoDeCode::pop()
{
    mMsgQ.pop();
}

int main()
{
    uint32_t len = 0;
    uint8_t * pData = NULL;
    MyProtoMsg msg1;
    MyProtoMsg msg2;
    MyProtoDeCode myDecode;
    MyProtoEnCode myEncode;

    msg1.head.server = 1;
    msg1.body["op"] = "set";
    msg1.body["key"] = "id";
    msg1.body["value"] = "9856";

    msg2.head.server = 2;
    msg2.body["op"] = "get";
    msg2.body["key"] = "id";

    myDecode.init();
    pData = myEncode.encode(&msg1, len);
    if (!myDecode.parser(pData, len))
    {
        cout << "parser falied!" << endl;
    }
    else
    {
        cout << "msg1 parser successful!" << endl;
    }

    pData = myEncode.encode(&msg2, len);
    if (!myDecode.parser(pData, len))
    {
        cout << "parser falied!" << endl;
    }
    else
    {
        cout << "msg2 parser successful!" << endl;
    }

    MyProtoMsg * pMsg = NULL;
    while (!myDecode.empty())
    {
        pMsg = myDecode.front();
        myProtoMsgPrint(*pMsg);
        myDecode.pop();
    }
    
    return 0;
}

7.2运行测试

8.总结

不到350行的代码向我们展示了一个自定义的应用层协议该如何实现，当然这个协议是不够完善的，还可以对其完善，比如对协议体进行加密加强协议的安全性等。

转：https://segmentfault.com/a/1190000008740863

lostyears
关注
专栏目录
应用层自定制协议
BT_zhb的博客
07-15 450
应用层协议 我们在解决一个实际问题，满足日常需求的网络程序，都是在应用层。 协议就是一种“约定”，socket api 的接口，在读写数据的时候都是按”字符串“的方式来发送接受的，但是如果我们要传输一些”结构化的数据结构“就要自定制协议了； 网络计算器 例如，现在实现一个服务器版本的加法器，我们需要把客户端要计算的两个加数发送过去，然后服务器进行计算，最后再把计算结构返回到客户端； 约定方案： ...
自定义应用层通信协议
weixin_30364147的博客
04-06 579
标签:通信协议要素 1．通信协议的概念及其要素 在OSI开放互联参考模型中，对等实体之间数据单元在发送方逐层封装，在接收方的逐层解析。发送方N层实体从N+1层实体得到的数据包称为服务数据单元（Service Data Unit，SDU）。N层实体只将其视为需要本实体提供服务的数据，将服务数据单元进行封装，使其成为一个对方能够理解的数据单元（Protocol Data Unit，PDU...
自定义的应用层协议（转）
weixin_42525096的博客
04-09 361
原文：https://segmentfault.com/a/1190000008740863 参考： https://blog.csdn.net/sinat_31608641/article/details/103811030 https://download.csdn.net/download/binbinliu8/4462040 https://blog.csdn.net/adofs...
应用层—自定义协议
Dreadnaught的博客
12-06 938
应用层主要是干嘛的呢？？应用层协议定义了应用程序之间通信的规则和标准。定义了数据的格式数据交换的标准和接口规范。应用层协议包括：HTTP/HTTPS、FTP、SMTP 等。本篇暂时不介绍这些应用层协议。应用层自带的协议有很多，但也有很多时候，是需要程序员自己定义协议。假如，外卖现在打开某个外卖软件，显示的是商家列表，每一个商家都包含了很多信息，包括：商家的名称、商家图片、好评率、距离你的位置、评分等…这些信息都是通过网络，从服务器获取的。
【代码实战】：手把手教你构建自定义HTTP服务，不可错过的Python教程
[【代码实战】：手把手教你构建自定义HTTP服务，不可错过的Python教程](https://img-blog.csdnimg.cn/4eac4f0588334db2bfd8d056df8c263a.png) # 1. HTTP服务的基础知识 ## 1.1 HTTP概述 HTTP（HyperText Transfer ...
百度智能手环-手把手教你做智能手环.pdf百度智能手环-手把手教你做智能手环_.pdf
05-23
### 百度智能手环-手把手教你做智能手环 #### 重要知识点解析： **一、智能硬件背景知识** 1. **嵌入式系统介绍** - **定义**: 根据IEEE（国际电气和电子工程师协会）的定义，嵌入式系统是“用于控制、监视或者...
手把手教你配置SNMP
04-19
SNMP基于UDP（用户数据报协议），通常工作在应用层，其主要由三部分组成：管理站（Manager）、代理（Agent）和管理信息库（MIB）。 【SNMP版本】 SNMP有三个主要版本：SNMPv1、SNMPv2c和SNMPv3。SNMPv1是最基础的...
百度智能手环-手把手教你做智能手环.pdf
07-03
4.3 L2层command详解 第五章 智能手环客户端 5.1 客户端概述 5.2 硬件厂商所需工作 5.3 客户端系统架构 5.4 客户端应用下载地址 第六章 智能手环测试 6.1 手环工厂测试软件 6.2 工厂自动测试流程 6.3 质量发布标准 ...
MyProtocol:手把手教你实现自定义的应用层协议
05-16
协议设计 协议头 8字节的定长协议头。支持版本号，基于魔数的快速校验，不同服务的复用。定长协议头使协议易于解析且高效。 协议体 变长json作为协议体。json使用明文文本编码，可读性强、易于扩展、前后兼容、通用的编解码算法。json协议体为协议提供了良好的扩展性和兼容性。 协议可视化图 协议实现 /* 协议头 */ struct MyProtoHead { uint8_t version; //协议版本号 uint8_t magic; //协议魔数 uint16_t server; //协议复用的服务号，标识协议之上的不同服务 uint32_t len; //协议长度（协议头长度+变长json协议体长度） }; 协议消息体 /* 协议消息体 */ struct MyProtoMsg { MyPr
自定义类QQ应用层协议，不同用户之间的在线交互
07-08
socket编程，自定义类QQ应用层协议，达到多用户在线交互，互相通信且知道信息来源和历史消息，具有登录和退出功能，能够很好的理解tcp协议，而进一步了解http或ip协议
EXata自定义应用层协议
zhang1806618的博客
03-18 982
一、新建协议库 1.新建头文件和源文件app_myprotocol.h和源文件app_myprotocol.cpp，新协议命名"myprotocol"，在头文件中声明并在源文件中写出空函数初始化函数AppMyprotocol_Init()、事件处理函数AppMyprotocol_Layer()、定型函数AppMyprotocol_Finalize。 2.将协议包括在应用层协议和跟踪协议列表中，在application.h的enum AppType中倒数第二个位置添加新协议名称“APP_MYPROTOCO
【计算机网络】应用层自定义协议
YoungMLet的博客
02-26 2665
认识应用层自定义协议，序列化和反序列化，基于定制自定义协议和序列化反序列化实现网络版的计算器！最后认识使用 JSON 进行序列化和反序列化！
自定义应用层通信协议(1)
s_k_yliu的专栏
08-19 791
http://blog.csdn.net/zhanghefu/article/details/5163963
【网络】应用层协议（自定义协议）（序列和反序列化）
最新发布
m0_70088010的博客
07-27 904
自定义协议和序列反序列化
网络编程五--自定义应用层协议
SNAKEpc12138的博客
05-08 906
本章通过一个简单的运算示例介绍如何自定义应用层协议，所谓的协议就是为了完成数据交换而定好的约定，只不过这里的约定应用在了应用层，即输入前（客户端的应用层）、输出后（服务器端的应用层）的数据的处理方式。
如何自定义应用层协议?
欢迎来到我的博客，在这里我会用我的方式来讲解知识，请大家多多关照
08-26 622
如何自定义应用层协议呢???确定好要组织的信息.确定好对信息的组织形式用来区分数据信息.
应用层自定义协议以及序列化和反序列化
Xpccccc的博客
07-24 1120
应用层自定义协议以及序列化和反序列化
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值