《Linux網路開發必學教程》9_應用協議解析模組（上）

TianSong發表於2022-05-06
Linux協議
問題：如何在程式碼層面封裝協議細節？如何將接收緩衝區中的資料解析為 Message ?

深度思考

資料是否能夠解析成為 Message ?

  • 資料量足夠

    • 如果資料量足夠，是否能夠解析不止一個 Message？
    • 如何處理剩餘資料 （屬於下一個 Message）

  • 資料量不足

    • 是否達到協議最小長度（12 位元組）?
    • 如何處理資料量超過最小長度，但不足以建立一個 Message 的情況？

初步的解決方案

  • 定義一個模組用於從位元組流解析 Message
  • 可 從指定記憶體 或 從指定檔案描述符 讀取並解析

  • 當至少存在 12 個位元組時開始解析

    • 首先解析協議中的頭資訊和資料區長度（length）
    • 根據資料區長度繼續從位元組流讀取資料（payload）
    • 當協議資料解析完成時，建立 Message 並返回，否則，返回 NULL

協議解析模組的初步設計

解析器介面定義
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);
解析器資料結構
typedef struct msg_parser {
    Message cache;    // 快取已解析的訊息頭
    int header;        // 標識訊息頭是否解析成功
    int need;        // 標識還剩多少位元組才能完成解析
    Message *msg;    // 解析中的協議訊息（半成品）
}MsgParser;
條件：記憶體長度至少連續 12 個位元組
memcpy(&p->cache, mem, p->need);

p->cache.type   = ntohs(p->cache.type);  // 從網路位元組序轉換為本機位元組序
p->cache.cmd    = ntohs(p->cache.cmd);
p->cache.index  = ntohs(p->cache.index);
p->cache.total  = ntohs(p->cache.total);
p->cache.length = ntohs(p->cache.length);

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

p->header = 1;
p->need = p->cache.length;
從記憶體中讀取 payload 中的資料（可讀取多次）
if (!p->msg) {  // 成功建立訊息頭之後， 建立 Message
    p->msg = malloc(sizeof(p->cache) + p->need);

    if (p->msg) {
        *p->msg = p->cache;
    }
}

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

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

    p->need -= len;
}

程式設計實驗：協議解析模組初步設計

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 *parse);
void MParser_Del(MParser *parse);

#endif
msg_parser.c
#include <malloc.h>
#include <string.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;

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

    MParser_Reset(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) {
        return ret;
    }

    if (!p->header) {
        if (p->need <= length) {
            memcpy(&p->cache, mem, p->need);
            p->cache.type = ntohs(p->cache.type);
            p->cache.cmd = ntohs(p->cache.cmd);
            p->cache.index = ntohs(p->cache.index);
            p->cache.total = ntohs(p->cache.total);
            p->cache.length = ntohl(p->cache.length);

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

            p->header = 1;
            p->need = p->cache.length;

            ret = MParser_ReadMem(parser, mem, length);
        }
    } else {
        if (!p->msg) {
            p->msg = malloc(sizeof(p->cache) + p->need);

            if (p->msg) {
                *p->msg = p->cache;
            }
        }

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

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

            p->need -= len;
        }

        if (!p->need) {
            ret = p->msg;
            p->msg = NULL;
            MParser_Reset(p);
        }
    }

    return ret;
}

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

    return ret;
}

void MParser_Reset(MParser *parse)
{
    MsgParser *p = (MsgParser*)parse;

    if (p) {
        p->header = 0;
        p->need = sizeof(p->cache);

        free(p->msg);

        p->msg = NULL;
    }
}

void MParser_Del(MParser *parse)
{
    MsgParser *p = (MsgParser*)parse;

    if (p) {
        free(p->msg);
        free(p);
    }
}
test.c
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>

#include "msg_parser.h"

int main()
{   
    MParser *p = MParser_New();
    char buf[] = {0x00, 0x01, 0x00, 0x02, 0x00, 0x03, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04};
    char data[] = {0x11, 0x12, 0x13, 0x14};
    Message *m = MParser_ReadMem(p, buf, sizeof(buf));
    int i = 0;

    if (!m) {
        printf("parse again...\n");

        m = MParser_ReadMem(p, data, sizeof(data));
    }

    printf("m = %p\n", m);

    if (m) {
        printf("type = %d\n", m->type);
        printf("cmd = %d\n", m->cmd);
        printf("index = %d\n", m->index);
        printf("total = %d\n", m->total);
        printf("length = %d\n", m->length);

        for (i=0; i<m->length; ++i) {
            printf("0x%02x ", m->payload[i]);
        }

        printf("\n");

        free(m);
    }

    MParser_Del(p);

    return 0;    
}
思考：如何通過 socket 檔案描述符實時解析協議資料？

相關文章