C++ Exercises（十六）---Ethernet帧包结构解析

图1是一个假想的帧包结构，

图2是解包后的结果。

/////////////////////////////
///帧信息类 
/////////////////////////////
class CFrame
{
public:
    CFrame(void);
    ~CFrame(void);
    void setSerialNumber(int nSN);
    void setPreCode(const string& strPreCode);
    void setPreBoundCode(const string& strBoundCode);
    void setEtherType(const string& strEtherType);
    void setData(char* strData,int len);
    void setCRC(const string& strCRC);
    void setFrameState(bool isValid);
    void setDstAddress(const string& desAddress);
    void setSrcAddress(const string& srcAddress);
private:
    int nFrameSN;// 帧序号
    string strPreCode;//前导码
    string strPreBoundCode;//帧前定界符
    string strDstAddress;//目的地址
    string strSrcAddress;//源地址
    string strEtherType;//帧类型
    string strData;//数据域
    string strCRC;//CRC校验码
    bool bIsValid;//是否正确的帧
    friend ostream& operator << (ostream& out,const CFrame& frame);
};

CFrame::CFrame(void)
{
    this->nFrameSN = -1;
    this->bIsValid = false;
    this->strEtherType = "";
    this->strCRC = "";
    this->strData = "";
    this->strDstAddress = "";
    this->strPreBoundCode = "";
    this->strPreCode = "";
    this->strSrcAddress = "";
}

CFrame::~CFrame(void)
{
}

void CFrame::setSerialNumber(int nSN)
{
    this->nFrameSN = nSN;
}

void CFrame::setPreCode(const string& strPreCode)
{
    this->strPreCode = strPreCode;
}
void CFrame::setPreBoundCode(const string& strBoundCode)
{
    this->strPreBoundCode = strBoundCode;
}
void CFrame::setEtherType(const string& strEtherType)
{
    this->strEtherType = strEtherType;
}
void CFrame::setData(char* strData,int len)
{
    this->strData = string(strData,len);
}

void CFrame::setCRC(const string& strCRC)
{
    this->strCRC = strCRC;
}

void CFrame::setFrameState(bool isValid)
{
    this->bIsValid = isValid;
}
void CFrame::setDstAddress(const string& desAddress)
{
    this->strDstAddress = desAddress;
}
void CFrame::setSrcAddress(const string& srcAddress)
{
    this->strSrcAddress = srcAddress;
}

 

/////////////////////////////
///帧解析器类
///////////////////////////

class CFrameParser
{
public:
    CFrameParser(void);
    CFrameParser(const char* pFilePath);
    CFrameParser(const string& strFilePath);
    ~CFrameParser(void);
    bool DoParser();//实际的解析动作
private:
    string strInputFile;//帧数据文件
    vector<CFrame> vecFrames;//帧包列表
    
};


CFrameParser::CFrameParser(void)
{
}

CFrameParser::~CFrameParser(void)
{
}

CFrameParser::CFrameParser(const char* pFilePath):strInputFile(pFilePath)
{

}
CFrameParser::CFrameParser(const string& strFilePath):strInputFile(strFilePath)
{

}

bool CFrameParser::DoParser()
{    // 检测输入文件是否存在，并可以按所需的权限和方式打开
    ifstream file(this->strInputFile.c_str(), ios::in|ios::binary|ios::_Nocreate);
    if (!file.is_open())
    {
        cout << "无法打开帧封装包文件，请检查文件是否存在并且未损坏" << endl;
        return false;
    }
    
    // 变量声明及初始化
    int nSN = 1;                        // 帧序号
    int nCheck = 0;                        // 校验码
    int nCurrDataOffset = 22;            // 帧头偏移量
    int nCurrDataLength = 0;            // 数据字段长度
    bool bParseCont = true;                // 是否继续对输入文件进行解析
    int nFileEnd = 0;                    // 输入文件的长度
    // 计算输入文件的长度
    file.seekg(0, ios::end);            // 把文件指针移到文件的末尾
    nFileEnd = file.tellg();            // 取得输入文件的长度
    file.seekg(0, ios::beg);            // 文件指针位置初始化
    cout.fill('0');                        // 显示初始化
    cout.setf(ios::uppercase);            // 以大写字母输出
    // 定位到输入文件中的第一个有效帧
    // 从文件头开始，找到第一个连续的“AA-AA-AA-AA-AA-AA-AA-AB”
    while ( true )
    {        
        for (int j = 0; j < 7; j++)                // 找个连续的xaa
        {            
            if (file.tellg() >= nFileEnd)        // 安全性检测
            {
                cout<<"没有找到合法的帧"<<endl;
                file.close();
                return false;
            }
            // 看当前字符是不是xaa，如果不是，则重新寻找个连续的xaa
            if (file.get() != 0xaa)                
            {
                j = -1;
            }
        }
        if (file.tellg() >= nFileEnd)            // 安全性检测
        {
            cout<<"没有找到合法的帧"<<endl;
            file.close();
            return false;
        }
        if (file.get() == 0xab)                    // 判断个连续的xaa之后是否为xab
        {
            break;
        }
    }
    // 将数据字段偏移量定位在上述二进制串之后字节处，并准备进入解析阶段
    nCurrDataOffset = static_cast<int>(file.tellg()) + 14;
    file.seekg(-8,ios::cur);

    // 主控循环
    while ( bParseCont ) // 当仍然可以继续解析输入文件时,继续解析
    {
        // 检测剩余文件是否可能包含完整帧头
        if (static_cast<int>(file.tellg())+ 14 > nFileEnd)// 从目的字段到类型字段总共14字节
        {
            cout<<endl<<"没有找到完整帧头，解析终止"<<endl;
            file.close();
            return false;
        }
        CFrame frame;
        int c;                        // 读入字节
        int i = 0;                    // 循环控制变量                    
        int EtherType = 0;            // 由帧中读出的类型字段
        bool bAccept = true;        // 是否接受该帧
        // 输出帧的序号
        frame.setSerialNumber(nSN);
        // 输出前导码，只输出，不校验
        string tmpPreCode="";
        for (i = 0; i <7; i++)                    // 输出格式为：AA AA AA AA AA AA AA
        {
            c = file.get();
            string hexCode = util::ConvertToHex(c);
            tmpPreCode.append(hexCode);
            if (i!=6)
            {
                tmpPreCode.append(1,' ');
            }
        }
        frame.setPreCode(tmpPreCode);
        // 输出帧前定界符，只输出，不校验
        cout << endl << "帧前定界符：/t";        
        cout.width(2);                            // 输出格式为：AB
        c = file.get();
        string tmpBoundCode = util::ConvertToHex(c);
        frame.setPreBoundCode(tmpBoundCode);
        string tmpDesAddress;
        // 输出目的地址，并校验
        for (i = 1; i <=6; i++)                    // 输出格式为：xx-xx-xx-xx-xx-xx
        {
            c = file.get();
            string desAddr = util::ConvertToHex(c);
            tmpDesAddress.append(desAddr);
            if (i!=6)
            {
                tmpDesAddress.append(1,'-');
            }
            if (i == 1)                            // 第一个字节，作为“余数”等待下一个bit
            {
                nCheck = c;
            }
            else                                // 开始校验
            {
                util::CRC::checkCRC(nCheck, c);
            }
        }
        frame.setDstAddress(tmpDesAddress);
        string tmpSrcAddress;
        // 输出源地址，并校验
        for (i = 1; i <=6; i++)                    // 输出格式为：xx-xx-xx-xx-xx-xx
        {
            c = file.get();
            string srcAddr = util::ConvertToHex(c);
            tmpSrcAddress.append(srcAddr);
            if (i!=6)
            {
                tmpSrcAddress.append(1,'-');
            }
            util::CRC::checkCRC(nCheck, c);                // 继续校验
        }
        frame.setSrcAddress(tmpSrcAddress);
        //// 输出类型字段，并校验                            
        // 输出类型字段的高位
        c = file.get();
        util::CRC::checkCRC(nCheck, c);                    // CRC校验
        EtherType = c;
        // 输出类型字段的低位
        c = file.get();                        
        util::CRC::checkCRC(nCheck,c);                        // CRC校验
        EtherType <<= 8;                        // 转换成主机格式
        EtherType |= c;
        string tmpType = util::ConvertToType(EtherType);
        frame.setEtherType(tmpType);
        // 定位下一个帧，以确定当前帧的结束位置
        while ( bParseCont )
        {
            for (int i = 0; i < 7; i++)                    //找下一个连续的个xaa
            {                
                if (file.tellg() >= nFileEnd)            //到文件末尾，退出循环
                {
                    bParseCont = false;
                    break;
                }
                // 看当前字符是不是xaa，如果不是，则重新寻找个连续的xaa
                if (file.get() != 0xaa)
                {
                    i = -1;
                }
            }
            // 如果直到文件结束仍没找到上述比特串，将终止主控循环的标记bParseCont置为true
            bParseCont = bParseCont && (file.tellg() < nFileEnd);        
            // 判断个连续的xaa之后是否为xab
            if (bParseCont && file.get() == 0xab)        
            {
                break;
            }
        }
        // 计算数据字段的长度
        nCurrDataLength =                                
            bParseCont ?                                // 是否到达文件末尾
            (static_cast<int>(file.tellg()) - 8 - 1 - nCurrDataOffset) :    // 没到文件末尾：下一帧头位置- 前导码和定界符长度- CRC校验码长度- 数据字段起始位置
        (static_cast<int>(file.tellg()) - 1 - nCurrDataOffset);        // 已到达文件末尾：文件末尾位置- CRC校验码长度- 数据字段起始位置
        // 以文本格式数据字段，并校验
        char* pData = new char[nCurrDataLength];    // 创建缓冲区
        file.seekg(bParseCont ? (-8 - 1 -nCurrDataLength) : ( -1 - nCurrDataLength), ios::cur);
        file.read(pData, nCurrDataLength);                // 读入数据字段
        frame.setData(pData,nCurrDataLength);
        int nCount = 50;                                // 每行的基本字符数量
        for (i = 0; i < nCurrDataLength; i++)            // 输出数据字段文本    
        {
            util::CRC::checkCRC(nCheck, (int)pData[i]);            // CRC校验
        }
        delete[] pData;                                    //释放缓冲区空间
        // 输出CRC校验码，如果CRC校验有误，则输出正确的CRC校验码
        cout << endl <<"CRC校验";
        c = file.get();                                // 读入CRC校验码
        int nTmpCRC = nCheck;
        util::CRC::checkCRC(nCheck, c);                        // 最后一步校验
        string strCRC = util::ConvertToHex(c);
        frame.setCRC(strCRC);
        if ((nCheck & 0xff) != 0)                    // CRC校验无误
        {
            bAccept = false;                        // 将帧的接收标记置为false
        }
        //    如果数据字段长度不足字节或数据字段长度超过字节，则将帧的接收标记置为false    
        if (nCurrDataLength < 46 ||    nCurrDataLength > 1500 )                            
        {
            bAccept = false;
        }
        frame.setFrameState(bAccept);
        vecFrames.push_back(frame);
        nSN++;                                    // 帧序号加
        nCurrDataOffset = static_cast<int>(file.tellg()) + 22;    // 将数据字段偏移量更新为下一帧的帧头结束位置
    }
    // 关闭输入文件
    file.close();
    return true;
}

 

namespace util
{//实用工具
    class CRC
    {
    public:
    ////////////////////////////////////////////////////////////////////////////////
        // CRC校验，在上一轮校验的基础上继续作位CRC校验
        // 
        //    输入参数：
        //        chCurrByte    低位数据有效，记录了上一次CRC校验的余数
        //        chNextByte    低位数据有效，记录了本次要继续校验的一个字节
        //
        //    传出参数：
        //        chCurrByte    低位数据有效，记录了本次CRC校验的余数
        ////////////////////////////////////////////////////////////////////////////////
        static void checkCRC(int &chCurrByte, int chNextByte)
        {
            // CRC循环：每次调用进行次循环，处理一个字节的数据。
            for (int nMask = 0x80; nMask > 0; nMask >>= 1)
            {
                if ((chCurrByte & 0x80) != 0)        // 首位为1：移位，并进行异或运算            {    
                    chCurrByte <<= 1;                // 移一位
                    if ( (chNextByte & nMask) != 0)    // 补一位
                    {
                        chCurrByte |= 1;
                    }
                    chCurrByte ^= 7;                // 首位已经移出，仅对低位进行异或运算，的二进制为,0111
                }
                else                                // 首位为0，只移位，不进行异或运算
                {        
                    chCurrByte <<= 1;                // 移一位
                    if ( (chNextByte & nMask) != 0)    // 补一位
                    {
                        chCurrByte |= 1;
                    }
                }
            }
        }
    };
    char mappingTable[] = {'0','1','2','3','4','5','6','7','8','9','A','B','C','D','E','F'};
    string ConvertToHex(int ch)
    {
        int high = ch/16;
        int low = ch%16;
        string result;
        result.append(1,mappingTable[high]);
        result.append(1,mappingTable[low]);
        return result;
    }
    string ConvertToType(int ch)
    {
        string result;
        int num,i;
        for (i=0;i<4;++i)
        {
            num = ch & 0x000F;
            ch>>=4;
            result.append(1,mappingTable[num]);
            if (i==1)
            {
                result.append(1,' ');
            }
        }
        
        for (i=0;i<=1;++i)
        {
            swap(result[i],result[4-i]);
        }
        return result;
    }
}