应用协议解析模块（下）

最新推荐文章于 2024-09-12 08:21:13 发布
最新推荐文章于 2024-09-12 08:21:13 发布
阅读量295 收藏 1
点赞数
分类专栏： 唐老师的网络编程 文章标签： 网络
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/LangLang_2020/article/details/122253246
版权

应用协议解析模块（下）

1、问题

如何通过socket文件描述符实时解析协议消息？

2、深度思考

从文件描述符是否能够获取足够的数据？

  • 数据量足够

    • 读取12字节解析消息头
    • 读取数据填充payload（length）

  • 数据量不足

    • 无法获取消息头所需数据（如何处理？解析状态如何切换？）
    • 无法获取payload完整数据（如何处理？是否追加？）

3、解决方案

策略：尽力获取数据，实时解析

  • 即便当前获取1字节，也可根据状态进行解析
  • 支持不同数据源多次接力解析（从内存或文件描述符交替获取数据）

充分利用解析器状态信息是实现解决方案的关键！！

4、解析器状态切换

image-20211229112338106

  • 状态切换函数
static void InitState(MsgParser* p)
{
    p->header = 0;
    p->need = sizeof(p->cache);
    
    free(p->msg);
    
    p->msg = NULL;
}

static int ToMidState(MsgParser* p)
{
	p->header = 1;
    p->need = p->cache.length;
    
    p->msg = malloc(sizeof(p->cache) + p->need);
    if( p->msg )
    {
        *p->msg = p->cache;
    }
    return !!p->msg;
}

static Message* ToLastState(MsgParser* p)
{
    Message* ret = NULL;
    
    if( p->header && !p->need )
    {
        ret = p->msg;
        p->msg = NULL;
    }
    return ret;
}

5、从文件描述符中获取数据

static int ToRecv(int fd, char* buf, int size)
{
    int retry = 0;
    int i = 0;
    
    while( i < size )
    {
        int len = read(fd, buf + i, size - i);
        if( len > 0 )
        {
            i += len;
        }
        else
        {
            if( retry++ > 5 )
            {
                break;
            }
            usleep(200 * 1000);
        }
    }
    return i;
}

6、从文件描述符中实时解析消息头

if( !p->header )
{
    int offset = sizeof(p->cahce) - p->need;
    //1.计算存放位置并读取消息头数据
    int len = ToRecv(fd, (char*)&p->cache + offset, p->need);
	if( len == p->need )
    {
        ntoh(&p->cache);
        //2.切换状态并读取payload数据
        if( ToMidState(p) )
        {
            ret = Mpaser_ReadFd(p, fd);
        }
    }
    else
    {
        p->need -= len;
    }
}

7、从文件描述符中获取payload数据

if( p->msg )
{
    int len = ToRecv(fd, p->msg->payload, p->need);
    p->need -= len;
}
//尝试切换到最终态，如果成功，则可获取协议消息，之后切换到初始态
if( ret = ToLastState(p) )
{
    InitState(p);
}

8、编程实战

//message.h
#ifndef _MESSAGE_DITAI_H_
#define _MESSAGE_DITAI_H_

typedef struct message
{
    unsigned short type;     //消息类型
    unsigned short cmd;      //命令
    unsigned short index;    //标识
    unsigned short total;    //总数
    unsigned int length;     //数据区长度
    unsigned char payload[]; //数据区（柔性数组）
}Message;

Message* Message_New(unsigned short type,
                    unsigned short cmd,
                    unsigned short index,
                    unsigned short total,
                    const char* payload,
                    unsigned int length);
                    

#endif

//message.c
#include "message.h"
#include <stdio.h>
#include <string.h>
#include <stdlib.h>

Message* Message_New(unsigned short type,
                    unsigned short cmd,
                    unsigned short index,
                    unsigned short total,
                    const char* payload,
                    unsigned int length)
{
    Message* ret = malloc(sizeof(Message) + length);
    if(ret)
    {
        ret->type = type;
        ret->cmd = cmd;
        ret->index = index;
        ret -> total = total;
        ret->length = length;

        if(payload)
        {
            memcpy(ret + 1, payload, length);
        }
    }
    return ret;
}


//msg_parser.h
#ifndef _MSG_PARSER_H_
#define _MSG_PARSER_H_

#include "message.h"

typedef void MParser;

MParser* MParser_New();
Message* MParser_ReadMem(MParser* parser, unsigned char* mem, unsigned int length);
Message* MParser_ReadFd(MParser* parser, int fd);
void MParser_Reset(MParser* parser);
void MParser_Del(MParser* parser);

#endif// _MSG_PARSER_H_


//msg_parser.c
#include <string.h>
#include <malloc.h>
#include <arpa/inet.h>
#include <unistd.h>

#include "msg_parser.h"

typedef struct msg_parser
{
    Message cache;  //缓存已解析的消息头
    int header;     //标识消息头是否解析成功
    int need;       //标识还需多少字节才能完成解析
    Message* msg;   //解析中的协议消息（半成品）
}MsgParser;

static void InitState(MsgParser* p)
{
    p->header = 0;
    p->need = sizeof(p->cache);
    
    free(p->msg);
    
    p->msg = NULL;
}

static int ToMidState(MsgParser* p)
{
	p->header = 1;
    p->need = p->cache.length;
    
    p->msg = malloc(sizeof(p->cache) + p->need);
    if( p->msg )
    {
        *p->msg = p->cache;
    }
    return !!p->msg;
}

static Message* ToLastState(MsgParser* p)
{
    Message* ret = NULL;
    
    if( p->header && !p->need )
    {
        ret = p->msg;
        p->msg = NULL;
    }
    return ret;
}

static void ntoh(Message* m)
{
    m->type = ntohs(m->type);
    m->cmd = ntohs(m->cmd);
    m->index = ntohs(m->index);
    m->total = ntohs(m->total);
    m->length = ntohl(m->length);
}

static int ToRecv(int fd, char* buf, int size)
{
    int retry = 0;
    int i = 0;
    
    while( i < size )
    {
        int len = read(fd, buf + i, size - i);
        if( len > 0 )
        {
            i += len;
        }
        else if( len < 0 )
        {
            break;
        }
        else
        {
            if( retry++ > 5 )
            {
                break;
            }
            usleep(200 * 1000);
        }
    }
    return i;
}

MParser* MParser_New()
{
    MParser* ret = calloc(1, sizeof(MsgParser));
    if( ret )
    {
        InitState(ret);
    }

    return ret;
}

Message* MParser_ReadMem(MParser* parser, unsigned char* mem, unsigned int length)
{
    Message* ret = NULL;
    MsgParser* p = (MsgParser*)parser;

    if( p && mem && length)
    {
        if( !p->header )//=0,解析器状态：还没解析
        {
            int len = (p->need < length) ? p->need : length;
            int offset = sizeof(p->cache) - p->need;
            
            memcpy((char*)&p->cache + offset, mem, len);
            if( p->need == len)
            {
                ntoh(&p->cache);

                mem += p->need;
                length -= p->need;

                if(ToMidState(p))
                {
                    ret = MParser_ReadMem(p, mem, length);//递归调用
                }
                else
                {
                    InitState(p);
                }

            }
            else
            {
                p->need -= len;
            }
        }
        else
        {
            if( p->msg )
            {
                int len = (p->need < length) ? p->need : length;
                int offset = p->msg->length - p->need;

                memcpy(p->msg->payload + offset, mem, len);

                p->need -= len;
            }

            if( ret = ToLastState(p) )
            {
                InitState(p);
            }
        }
    }
    return ret;
}

Message* MParser_ReadFd(MParser* parser, int fd)
{
    Message* ret = NULL;
    MsgParser* p = (MsgParser*)parser;

    if( (fd != -1)&& p )
    {
        if( !p->header )
        {
            //解析消息头
            int offset = sizeof(p->cache) - p->need;
            int len = ToRecv(fd, (char *)&p->cache + offset, p->need);

            if( len == p->need )
            {
                //状态切换
                ntoh(&p->cache);

                if( ToMidState(p) )
                {
                    ret = MParser_ReadFd(p, fd);
                }
                else
                {
                    //无法进入中间态，重置
                    InitState(p);
                }
            }
            else
            {
                p->need -= len;
            }
        }
        else
        {
            //解析payload
            if( p->msg )
            {
                int offset = p->msg->length - p->need;
                int len = ToRecv(fd, p->msg->payload + offset, p->need);
                p->need -= len;
            }

            if( ret = ToLastState(p) )
            {
                InitState(p);
            }
        }
    }
    return ret;
}

void MParser_Reset(MParser* parser)
{
    MsgParser* p = (MsgParser* )parser;
    if( p )
    {
        InitState(p);
    }
}

void MParser_Del(MParser* parser)
{
    MsgParser* p = (MsgParser* )parser;
    if( p )
    {
        free(p->msg);
        free(p);
    }
}


//server.c

#include <sys/types.h>
#include <sys/socket.h>
#include <netinet/in.h>
#include <netinet/tcp.h>
#include <arpa/inet.h>
#include <stdio.h>
#include <unistd.h>
#include <string.h>
#include <stdlib.h>
#include "msg_parser.h"

int main()
{
   
    int server = 0;
    struct sockaddr_in saddr = {0};
    int client = 0;
    struct sockaddr_in caddr = {0};
    socklen_t asize = 0;
    int len =0;
    char buf[32] = {0};
    int r = 0;
    MParser* parser = MParser_New();


    server = socket(PF_INET,SOCK_STREAM,0);

    if( server == -1)
    {
        printf("server socket err\n");
        return -1;
    }

    saddr.sin_family = AF_INET;
    saddr.sin_addr.s_addr = htonl(INADDR_ANY);
    saddr.sin_port = htons(20108);

    if( bind(server,(struct sockaddr*)&saddr, sizeof(saddr)) == -1 )
    {
        printf("server bind err\n");
        return -1;
    }

    if( listen(server,1) == -1 )
    {
        printf("listen err\n");
        return -1;
    }
    
    printf("server start success\n");

    while(1)
    {
        struct tcp_info info = {0};
        int l =sizeof(info);
        asize = sizeof(caddr);

        client = accept(server,(struct sockaddr*)&caddr, &asize);
        if(client == -1)
        {
            printf("client accept err\n");
            return -1;
        }

        printf("client : %d\n", client);

        do
        {
            getsockopt(client, IPPROTO_TCP, TCP_INFO, &info, (socklen_t*)&l);
            Message* m = MParser_ReadFd(parser, client);
            if( m )
            {
/*                printf("m->type = %d\n",m->type);
                printf("m->cmd = %d\n",m->cmd);
                printf("m->index = %d\n",m->index);
                printf("m->total = %d\n",m->total);
                printf("m->length = %d\n",m->length);
*/                printf("m->payload = %s\n",m->payload);
                
                free(m);
             
            }

        } while ( info.tcpi_state == TCP_ESTABLISHED );

        printf("i'll close client...\n");

        close(client);
    }
    close(server);
    printf("i'm closing server...\n");
    return 0;
}

//client.c
#include<sys/types.h>
#include<sys/socket.h>
#include<netinet/in.h>
#include<arpa/inet.h>
#include<stdio.h>
#include<unistd.h>
#include<string.h>
#include<malloc.h>
#include<string.h>
#include"message.h"

static void hton(Message* m)
{
    m->type = htons(m->type);
    m->cmd = htons(m->cmd);
    m->index = htons(m->index);
    m->total = htons(m->total);
    m->length = htonl(m->length);
}

int main()
{
    int sock = 0;
    struct sockaddr_in addr = {0};  
    int len = 0;
    int r = 0;
    int i = 0;
    char* test = "hello world!";
    Message* pm = NULL;

    sock = socket(PF_INET,SOCK_STREAM,0);
    if(sock == -1)
    {
        printf("socket err\n");
        return -1;
    }

    addr.sin_family = AF_INET;
    addr.sin_addr.s_addr = inet_addr("127.0.0.1");
    addr.sin_port = htons(20108);

    if(connect(sock,(struct sockaddr*)&addr,sizeof(addr)) == -1)
    {
        printf("connect err\n");
        return -1;
    }

    printf("connect success\n");

    for(i = 0; i < strlen(test); i++)
    {
        char buff[2] = {0};

        buff[0] = test[i];

        pm = Message_New(128, 129, i, strlen(test), buff, 2);

        hton(pm);

        send(sock, pm, sizeof(Message) + 2, 0);

        free(pm);
    }

    close(sock);

    return 0;
}
TCP协议解析
mac_timmy
07-21 807
TCP概述及特点 TCP报头 理解TCP的连接管理机制 连接 链接的工作 三次握手 三次握手出现报文丢失的情况分析： 为什么不是二次握手，四次握手？ 断开 四次挥手 TIME_WAIT状态 半关闭 同时关闭 状态转换 服务器端状态转化 可靠传输 流量控制 拥塞控制 异常终止 粘包问题 基于TCP的应用协议 本文主体参考谢希仁老先生计算机网络一书 TCP概...
Linux 网络开发必学课程（四）应用层协议设计与实现、应用层协议解析模块
Exp.Joker
06-07 818
应用层协议设计。如何在代码层面封装协议细节（仅关心消息本身)？如何通过socket文件描述符实时解析协议消息？
应用层协议解析模块
qq_52484093的博客
01-20 525
问题 如何在代码层面封装协议细节？ 如何接收缓冲区中的数据解析成为 Message？ 深度思考 初步的解决方案 定义一个模块用于字节流解析 Message 可 从指定内存 或 从指定文件描述符 读取并解析 当至少存在12个字节时开始解析 1. 首先解析协议中的头信息和数据区长度 (length) 2. 根据数据区长度继续从字节流读取数据 (payload) 3. 当协议数据解析完成时，创建 Message 并返回，否则，返回 NULL 协议解析模块的初步设计 解析器
应用协议解析模块（上）
LangLang_2020的博客
12-31 208
应用协议解析模块（上） 1、问题 如何在代码层面封装协议细节？ 如何将接收缓冲区中的数据解析成为Message？ 1.1深度思考 数据是否能够解析成为Message？ 数据量足够 如果数据量足够，是否能够解析不止一个Messge？ 如何处理剩余数据（属于下一个Message）？ 数据量不足 是否达到协议最小长度（12字节）？ 如何处理数据量超过最小长度，但不足以创建一个Message的情况？ 2、初步解决方案 定义一个模块用于从字节流解析Message 可从指定内存或从指定文件描述符读取并
（9）应用层协议解析模块（上）
u013732741的博客
09-25 355
3：当协议数据解析完成时，创建Message并返回，否则返回NULL；2：根据数据区长度继续从字节流读取数据（payload）；1：首先解析协议中的头信息和数据区长度（length）；
基于Linux下的VIM、Mac下的idea实现的协议分析软件
毕业作品网站
05-31 318
一、任务概述 1.1 设计目的 使学生深入理解和掌握计算机网络的基本理论及工作原理，熟悉计算机网络和互联网的组成，运用计算机网络知识设计协议分析软件，并进行网络协议分析，最后通过网页呈现，加深对计算机网络系统的认知、设计与应用开发能力，同时培养学生运用计算机网络技术解决实际问题的能力。 1.2 项目任务和要求 要求学生掌握计算机网络协议原理、协议分析方法及协议分析软件的开发。理解网络协议的层次结构及网络协议的工作过程，掌握网络协议的分析方法及网络协议的设计与应用。 1.3 参考资料 ·《计算机网络》，谢希仁
Java版DLT645-2007电能表协议解析源码(串口协议解析)
02-16
Java版的DLT645-2007电能表协议解析源码是用于处理电能表通信的一种软件开发资源，尤其适用于那些需要通过串行接口与电能表进行数据交互的应用。这个协议是中国电力行业的一个标准，规定了电能表与数据采集系统之间...
东信身份证读卡安全控制模块协议解析说明.pdf
05-16
总之，东信身份证读卡安全控制模块协议解析涉及到了读卡流程的三个关键步骤，需要对身份证信息进行字节级的解析，并且要特别关注数据的正确性和安全性。在实际应用中，除了技术解析之外，还必须确保遵守相关的法律...
DL698协议主站软件，协议解析软件，最新版
06-15
总的来说，DL698协议主站软件是电力行业实现自动化和智能化的重要工具，其背后涉及的通信协议解析、数据库管理、安全机制等多个方面的技术，对于理解和研究智能电网有着重要的价值。随着科技的发展，我们可以期待更...
一种新的NMEA0183协议解析方法实现_刘赋山_NMEA模块_NMEA0183解析_nmea0183_NMEA_
09-29
：ＮＭＥＡ０１８３协议解析模块是导航系统中至关重要的软件模块，该模块的健壮性和高效性直接关系到整个导航系统的性能。为了能及时并高效解析ＮＭＥＡ 数据流，分开处理ＮＭＥＡ数据流解析与数据显示，降低解析...
基于DPI的应用层协议解析.doc
10-08
【系统架构】应用层协议解析系统通常由数据包捕获模块、协议解析模块、存储模块和控制模块等组成。数据包捕获模块负责从网络接口获取数据包，协议解析模块对数据包进行解析，提取应用层信息，存储模块保存解析结果，...
msgparser-开源
05-01
msgparser是一个小型的开源Java库，它解析Outlook .msg文件并使用Java对象提供其内容。 注意：此项目不再由https://github.com/bbottema/outlook-message-parser维护和取代
Linux-socket详解
icepopfh的博客
07-21 1219
OSI七层模型和TCP/IP四层模型在这里就不说了。套接字（socket）是一个抽象层，应用程序可以通过它发送或接收数据，可对其进行像对文件一样的打开、读写和关闭等操作。套接字允许应用程序将IO插入到网络中，并与网络中的其他应用程序进行通信。网络套接字是IP地址与端口的组合。Socket是一种编程接口，使应用程序能够使用TCP/IP协议进行网络通信。应用层协议是构建在Socket和TCP/IP之上的，用于实现不同应用程序之间的通信规则。
Lwip pbuff分析
一个早起的程序员
02-12 1710
在BSD中用mbuf结构体来管理网络上来的各种数据包，同样lwip中也有一个类似的结构体pbuf用来管理数据包。Pbuf结构体定义如下： structpbuf{ structpbuf *next; ...
msg_parser：一个强大的Outlook MSG文件解析器
最新发布
gitblog_00612的博客
09-12 662
msg_parser：一个强大的Outlook MSG文件解析器 msg_parser 项目地址: https://gitcode.com/gh_mirrors/ms/msg_parser ...
msg_parser 开源项目安装与使用指南
gitblog_00717的博客
09-12 409
msg_parser 开源项目安装与使用指南 msg_parser 项目地址: https://gitcode.com/gh_mirrors/ms/msg_parser m...
GPS通讯协议（NMEA0183）协议解析
马道人生
03-11 2万+
核心提示：说起NMEA协议，只要接触过GPS设备的人，或者说是要用到GPS设备研发的人都知道，这是一个很常用的GPS通讯协议，而且也有很多人遇到关于NEMA协议的一些问题 说起NMEA协议，只要接触过GPS设备的人，或者说是要用到GPS设备研发的人都知道，这是一个很常用的GPS通讯协议，而且也有很多人遇到关于NEMA协议的一些问题，我忽然有一个想法，就是按照自己对这个协议的一些理解，写一点这方面
协议分析工具学习TCP/IP(一)
xjbclz的专栏
07-12 1937
一、 前言  　　曾在赛迪网发过一篇《用协议分析工具学习TCP/IP》（以下简称"学习"），看到"希望能够再次提供其它的补充"的留言就一直考虑补充些什么，要补充的东西很多，毕竟TCP/TP协议簇是Internet的根基，不管在网上跑什么服务，归根结底都是建立在TCP/TP协议的基础上，要学的东西很多，"学习"一文概述了数据的传送过程，讲到了TCP标志位的变化，本文重点阐述TCP的状态变迁的情
i2c 相关知识总结（转）
热门推荐
追逐梦想的脚步
12-19 6万+
一. 技术性能: 工作速率有100K和400K两种； 支持多机通讯； 支持多主控模块，但同一时刻只允许有一个主控； 由数据线SDA和时钟SCL构成的串行总线； 每个电路和模块都有唯一的地址； 每个器件可以使用独立电源 二. 基本工作原理: 以启动信号START来掌管总线，
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值