devbox
Gausst松鼠会
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

C++ TLV格式解析

作者：Gausst松鼠会 | 2024-04-27 15:01:38

赞

踩

tlv格式

一、什么是TLV格式?

   TLV即Tag-Length-Value，常在IC卡与POS终端设备中通过这样的一个应用通信协议进行数据交换。 金融系统中的TLV是BER-TLV编码的一个特例编码规范，而BER-TLV是ISO定义中的规范。在TLV的定义中，可以知道它包括三个域，分别为：标签域（Tag），长度域（Length），内容域（Value）。这里的长度域的值实际上就是内容域的长度。 其实，在BER编码的方式有两种情况，一种是确定长度的方式，一种是不确定长度的方式，而金融TLV选择了确定长度的方式，这样在设备之间的数据传输量上就可以减少。

1）Tag域

2）Length域

   当b8为0时，该字节的b7-b1作为value域的长度；当b8为1时，b7-b1作为后续字节的长度。例：10000011，代表后续还有3个字节作为value域的长度（本字节不算，本字节变为作为一个Length的索引）。3个字节代表value的长度，意味着什么呢，意味着内容的长度当需要很大的时候，字节的位数就会跟着越高，3个字节就代表最大可以有256*256*256的长度。

3）Value域

   分成两种情况考虑，就是前面说到的Tag分成两个数据元结构，一种是简单数据元结构，一种是复合数据元架构：

   先来看看简单数据元结构：

 

   复合数据元结构：

 

  后面的Value说明：Primitive or constructed BER-TLV data object number，包含一个简单数据元结构或者也可以是一个符合数据元结构。这样可以看出，算法中必须要实现Tag的嵌套功能，递归算法不可少。

4）TLV格式数据实例

数据： 5F2D027A68

Tag域

5F → 01011111 → 5F 2D → 00101101 → 5F2D

Length域

02 → 00000010 → 02(2字节)

Value域

7A68

5）算法实现（ C++）

       根据以上的说明现在来实现它的打包解包的算法（打包的目的是将一个从终端上发的请求数据——字节数组，构造成一系列的TLV结构实体；解包的目的刚好相反，就是将TLV结构实体解析成字节数组，然后通过IC卡发送到终端上）。

      首先定义一个TLV结构实体：

  1. // TLV结构体
  2.  
  3. struct TLVEntity {
  4.  
  5.     unsigned char* Tag;         //标记
  6.  
  7.     unsigned char* Length;      //数据长度
  8.  
  9.     unsigned char* Value;       //数据
  10.  
  11.     unsigned int TagSize;       //标记占用字节数
  12.  
  13.     unsigned int LengthSize;    //数据长度占用字节数
  14.  
  15.     TLVEntity* Sub_TLVEntity;   //子嵌套TLV实体
  16.  
  17. };

其中TagSize代表Tag字段的字节长度，LengthSize代表Length的字节长度，这里的Length记住要使用char*，由于前面说过，Length可能包含

多个字节，通过多个字节确定Value域的长度，Sub_TLVEntity作为子嵌套的TLV结构体。

    定义一个TLVPackage的打包类：

TLVPackage.h：

  1. // TLV打包类
  2.  
  3. class TLVPackage
  4.  
  5. {
  6.  
  7. public:
  8.  
  9.     TLVPackage();
  10.  
  11.     virtual ~TLVPackage();
  12.  
  13.     //构造TLV实体
  14.  
  15.     static void Construct(unsigned char* buffer, unsigned int bufferLength, TLVEntity* tlvEntity, unsigned int& entityLength, unsigned int status=0);
  16.  
  17.     //解析TLV字节数组
  18.  
  19.     static void Parse(TLVEntity* tlvEntity, unsigned int entityLength, unsigned char* buffer, unsigned int& bufferLength);
  20.  
  21. };

具体实现 方法 ：

  1. // 构造TLV
  2.  
  3. void TLVPackage:: Construct(
  4.  
  5.     unsigned char* buffer,
  6.  
  7.     unsigned int bufferLength,
  8.  
  9.     TLVEntity* tlvEntity,
  10.  
  11.     unsigned int& entityLength,
  12.  
  13.     unsigned int status
  14.  
  15.     )
  16.  
  17. {
  18.  
  19.     int currentTLVIndex = 0;
  20.  
  21.     int currentIndex = 0;
  22.  
  23.     int currentStatus = 'T'; //状态字符
  24.  
  25.     unsigned long valueSize = 0;
  26.  
  27.  
  28.     while(currentIndex < bufferLength)
  29.  
  30.     {
  31.  
  32.         switch(currentStatus)
  33.  
  34.         {
  35.  
  36.         case 'T':
  37.  
  38.             valueSize = 0;
  39.  
  40.             //判断是否单一结构
  41.  
  42.             if((status == 1 && buffer[currentIndex] & 0x20) != 0x20)
  43.  
  44.             {
  45.  
  46.                 tlvEntity[currentTLVIndex].Sub_TLVEntity = NULL; //单一结构时将子Tag置空
  47.  
  48.                 //判断是否多字节Tag
  49.  
  50.                 if((buffer[currentIndex] & 0x1f) == 0x1f)
  51.  
  52.                 {
  53.  
  54.                     int endTagIndex = currentIndex;
  55.  
  56.                     while((buffer[++endTagIndex] & 0x80) == 0x80); //判断第二个字节的最高位是否为1
  57.                     int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节
  58.  
  59.                     tlvEntity[currentTLVIndex].Tag = new unsigned char[tagSize];
  60.  
  61.                     memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, tagSize);
  62.                     tlvEntity[currentTLVIndex].Tag[tagSize] = 0;
  63.  
  64.                     tlvEntity[currentTLVIndex].TagSize = tagSize;
  65.  
  66.                     currentIndex += tagSize;
  67.  
  68.                 }
  69.  
  70.                 else
  71.  
  72.                 {
  73.  
  74.                     tlvEntity[currentTLVIndex].Tag = new unsigned char[1];
  75.  
  76.                     memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, 1);
  77.  
  78.                     tlvEntity[currentTLVIndex].Tag[1] = 0;
  79.  
  80.                     tlvEntity[currentTLVIndex].TagSize = 1;
  81.  
  82.                     currentIndex += 1;
  83.  
  84.                 }
  85.  
  86.             }
  87.  
  88.             else
  89.  
  90.             {
  91.  
  92.                 //判断是否多字节Tag
  93.  
  94.                 if((buffer[currentIndex] & 0x1f) == 0x1f)
  95.  
  96.                 {
  97.  
  98.                     int endTagIndex = currentIndex;
  99.  
  100.                     while((buffer[++endTagIndex] & 0x80) == 0x80); //判断第二个字节的最高位是否为1
  101.                     int tagSize = endTagIndex - currentIndex + 1; //计算Tag包含多少字节
  102.  
  103.                     tlvEntity[currentTLVIndex].Tag = new unsigned char[tagSize];
  104.  
  105.                     memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, tagSize);
  106.                     tlvEntity[currentTLVIndex].Tag[tagSize] = 0;
  107.  
  108.                     tlvEntity[currentTLVIndex].TagSize = tagSize;
  109.  
  110.                     currentIndex += tagSize;
  111.  
  112.                 }
  113.  
  114.                 else
  115.  
  116.                 {
  117.  
  118.                     tlvEntity[currentTLVIndex].Tag = new unsigned char[1];
  119.  
  120.                     memcpy(tlvEntity[currentTLVIndex].Tag, buffer + currentIndex, 1);
  121.  
  122.                     tlvEntity[currentTLVIndex].Tag[1] = 0;
  123.  
  124.                     tlvEntity[currentTLVIndex].TagSize = 1;
  125.  
  126.                     currentIndex += 1;             
  127.  
  128.                 }
  129.  
  130.                 //分析SubTag
  131.  
  132.                 int subLength = 0; 
  133.  
  134.                 unsigned char* temp;
  135.  
  136.                 if((buffer[currentIndex] & 0x80) == 0x80)
  137.  
  138.                 {
  139.  
  140.                     for (int index = 0; index < 2; index++)
  141.  
  142.                     {
  143.                         subLength += buffer[currentIndex + 1 + index] << (index * 8); //计算Length域的长度
  144.  
  145.                     }
  146.  
  147.                     temp = new unsigned char[subLength];
  148.  
  149.                     memcpy(temp, buffer + currentIndex + 3, subLength);
  150.  
  151.                 }
  152.  
  153.                 else
  154.  
  155.                 {
  156.  
  157.                     subLength = buffer[currentIndex];
  158.  
  159.                     temp = new unsigned char[subLength];
  160.  
  161.                     memcpy(temp, buffer + currentIndex + 1, subLength);
  162.  
  163.                 }
  164.  
  165.                 temp[subLength] = 0;
  166.  
  167.                 //memcpy(temp, buffer + currentIndex + 1, subLength);
  168.  
  169.                 unsigned int oLength;
  170.  
  171.                 tlvEntity[currentTLVIndex].Sub_TLVEntity = new TLVEntity[1];
  172.  
  173.                 Construct(temp, subLength, tlvEntity[currentTLVIndex].Sub_TLVEntity, oLength);
  174.  
  175.             }
  176.  
  177.  
  178.             currentStatus = 'L';
  179.  
  180.             break;
  181.  
  182.         case 'L':      
  183.  
  184.             //判断长度字节的最高位是否为1，如果为1，则该字节为长度扩展字节，由下一个字节开始决定长度
  185.  
  186.             if((buffer[currentIndex] & 0x80) != 0x80)
  187.  
  188.             {
  189.  
  190.                 tlvEntity[currentTLVIndex].Length = new unsigned char[1];
  191.  
  192.                 memcpy(tlvEntity[currentTLVIndex].Length, buffer + currentIndex, 1);
  193.  
  194.                 tlvEntity[currentTLVIndex].Length[1] = 0;
  195.  
  196.                 tlvEntity[currentTLVIndex].LengthSize = 1;
  197.  
  198.                 valueSize = tlvEntity[currentTLVIndex].Length[0];
  199.  
  200.                 currentIndex += 1;
  201.  
  202.             }
  203.  
  204.             else
  205.  
  206.             {
  207.  
  208.                 //为1的情况
  209.  
  210.                 unsigned int lengthSize = buffer[currentIndex] & 0x7f;
  211.  
  212.                 currentIndex += 1; //从下一个字节开始算Length域
  213.  
  214.                 for (int index = 0; index < lengthSize; index++)
  215.  
  216.                 {
  217.  
  218.                     valueSize += buffer[currentIndex + index] << (index * 8); //计算Length域的长度
  219.  
  220.                 }
  221.  
  222.  
  223.                 tlvEntity[currentTLVIndex].Length = new unsigned char[lengthSize];
  224.  
  225.                 memcpy(tlvEntity[currentTLVIndex].Length, buffer + currentIndex, lengthSize);
  226.                 tlvEntity[currentTLVIndex].Length[lengthSize] = 0;
  227.  
  228.  
  229.                 tlvEntity[currentTLVIndex].LengthSize = lengthSize;
  230.  
  231.                 currentIndex += lengthSize;
  232.  
  233.             }
  234.  
  235.             currentStatus = 'V';
  236.  
  237.             break;
  238.  
  239.         case 'V':
  240.  
  241.             tlvEntity[currentTLVIndex].Value = new unsigned char[valueSize];
  242.  
  243.             memcpy(tlvEntity[currentTLVIndex].Value, buffer + currentIndex, valueSize);
  244.  
  245.             tlvEntity[currentTLVIndex].Value[valueSize] = 0;
  246.  
  247.             currentIndex += valueSize;
  248.  
  249.             //进入下一个TLV构造循环
  250.  
  251.             currentTLVIndex += 1;
  252.  
  253.             currentStatus = 'T';
  254.  
  255.             break;
  256.  
  257.         default:
  258.  
  259.             return;
  260.  
  261.         }
  262.  
  263.     }
  264.  
  265.     entityLength = currentTLVIndex;
  266.  
  267. }
  268.  
  269.  
  270.  
  271. // 解析TLV
  272.  
  273. void TLVPackage::Parse(
  274.  
  275.     TLVEntity* tlvEntity,
  276.  
  277.     unsigned int entityLength,
  278.  
  279.     unsigned char* buffer,
  280.  
  281.     unsigned int& bufferLength
  282.  
  283.     )
  284.  
  285. {
  286.  
  287.     int currentIndex = 0;
  288.  
  289.     int currentTLVIndex = 0;
  290.  
  291.     unsigned long valueSize = 0;
  292.  
  293.     while(currentTLVIndex < entityLength)
  294.  
  295.     {
  296.  
  297.         valueSize = 0;
  298.  
  299.         TLVEntity entity = tlvEntity[currentTLVIndex];
  300.  
  301.         memcpy(buffer + currentIndex, entity.Tag, entity.TagSize);  //解析Tag
  302.  
  303.         currentIndex += entity.TagSize;
  304.  
  305.         for (int index = 0; index < entity.LengthSize; index++)
  306.  
  307.         {
  308.  
  309.             valueSize += entity.Length[index] << (index * 8); //计算Length域的长度
  310.  
  311.         }
  312.  
  313.         if(valueSize > 127)
  314.  
  315.         {
  316.  
  317.             buffer[currentIndex] = 0x80 | entity.LengthSize;
  318.  
  319.             currentIndex += 1;
  320.  
  321.         }
  322.  
  323.         memcpy(buffer + currentIndex, entity.Length, entity.LengthSize);    //解析Length
  324.  
  325.         currentIndex += entity.LengthSize;
  326.  
  327.         //判断是否包含子嵌套TLV
  328.  
  329.         if(entity.Sub_TLVEntity == NULL)
  330.  
  331.         {
  332.  
  333.             memcpy(buffer + currentIndex, entity.Value, valueSize); //解析Value
  334.  
  335.             currentIndex += valueSize;
  336.  
  337.         }
  338.  
  339.         else
  340.  
  341.         {
  342.  
  343.             unsigned int oLength;
  344.  
  345.             Parse(entity.Sub_TLVEntity, 1, buffer + currentIndex, oLength); //解析子嵌套TLV
  346.  
  347.             currentIndex += oLength;
  348.  
  349.         }
  350.  
  351.         currentTLVIndex++;
  352.  
  353.     }
  354.  
  355.     buffer[currentIndex] = 0;
  356.  
  357.     bufferLength = currentIndex;
  358.  
  359. }

写测试程序：

  1. // 上发测试数据
  2.  
  3. unsigned char requestBuf[] = {
  4.  
  5.         0x9F, 0x1C, 0x12, 0x33, 0x33, 0x30, 0x32, 0x32, 0x37, 0x31, 0x39, 0x36, 0x32, 0x30, 0x34, 0x30, 0x34,
  6.  
  7.         0x32, 0x37, 0x31, 0x38, 0x9F, 0x62, 0x01, 0x01, 0x57, 0x12, 0x62, 0x22, 0x89, 0x00, 0x00, 0x02, 0x91,
  8.  
  9.         0x01, 0xD0, 0x90, 0x32, 0x01, 0x02, 0x47, 0x17, 0x13, 0x00, 0x0F, 0x5F, 0x20, 0x0A, 0x48, 0x55, 0x47,
  10.  
  11.         0x55, 0x4F, 0x20, 0x4D, 0x49, 0x4E, 0x47, 0x9F, 0x1F, 0x3C, 0x25, 0x39, 0x39, 0x36, 0x32, 0x32, 0x32,
  12.  
  13.         0x38, 0x39, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x39, 0x31, 0x30, 0x31, 0x5E, 0x47, 0x55, 0x4F, 0x20,
  14.  
  15.         0x4D, 0x49, 0x4E, 0x47, 0x2F, 0x48, 0x55, 0x5E, 0x30, 0x39, 0x30, 0x33, 0x32, 0x30, 0x31, 0x30, 0x32,
  16.  
  17.         0x34, 0x37, 0x31, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x30, 0x32, 0x38, 0x39, 0x30,
  18.  
  19.         0x30, 0x3F
  20.  
  21. };
  22.  
  23.     TLVEntity tlvEntity[TLV_MAX_LENGTH];
  24.  
  25.     unsigned int tlv_count;
  26.  
  27.     //构造TLV
  28.  
  29.     TLVPackage::Construct(requestBuf, sizeof(requestBuf), tlvEntity, tlv_count);
  30.  
  31.     unsigned char parseBuf[1024];
  32.  
  33.     unsigned int buf_count;
  34.  
  35.     //解析TLV
  36.  
  37.     TLVPackage::Parse(tlvEntity, tlv_count, parseBuf, buf_count);
  38.  
  39.     if(strncmp((char*)parseBuf, (char*)requestBuf, sizeof(requestBuf)) == 0)
  40.  
  41.     {
  42.         AfxMessageBox("TRUE");
  43.  
  44.     }
  45.  
  46.     else
  47.  
  48.     {
  49.         AfxMessageBox("FALSE");
  50.  
  51.     }

最后测试结果中，可以得到最后将弹出“TRUE”的对话框。证明构造TLV得到的TLVEntity，再对这个实体进行解析，可以的到解析后的字节

数组， 最后通过strncmp的方法比较判断，是否原始字节数组和解析后的字节数组是否一致。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/Gausst松鼠会/article/detail/497268
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号