public static string GetStuctValue(ref byte[] bytesIn)
{
var listStr = new List <string>();
try
{
byte tag = 0;
var TotalBytes = bytesIn;
HeadDataStruct HeadData = new HeadDataStruct();
while (tag != (int)JceType.TYPE_STRUCT_END)
{
var len = readHead(bytesIn, ref HeadData);
tag = HeadData.typ;
if (tag == (int)JceType.TYPE_STRUCT_END)
{
bytesIn = bytesIn.Skip(1).ToArray();
break;
}
listStr.Add(GetFieldValue(ref bytesIn));
}
return(string.Join("/", listStr));
}
catch (Exception e1)
{
}
return("");
}
public static byte[] SkipLength(byte[] bytesIn, ref int Length, ref HeadDataStruct HeadData)
{
readHead(bytesIn, ref HeadData);
bytesIn = bytesIn.Skip(1).ToArray();
switch (HeadData.typ)
{
case (byte)JceType.TYPE_ZERO_TAG:
Length = 0;
return(bytesIn);
case (byte)JceType.TYPE_BYTE:
Length = bytesIn[0];
return(bytesIn.Skip(1).ToArray());
case (byte)JceType.TYPE_SHORT:
Length = Convert.ToInt32(BitConverter.ToInt16(bytesIn.Take(2).ToArray().Reverse().ToArray(), 0).ToString());
return(bytesIn.Skip(2).ToArray());
case (byte)JceType.TYPE_INT:
Length = Convert.ToInt32(BitConverter.ToInt32(bytesIn.Take(4).ToArray().Reverse().ToArray(), 0).ToString());
return(bytesIn.Skip(4).ToArray());
}
Length = -1;
return(bytesIn);
}
public static int readHead(byte[] bytesIn, ref HeadDataStruct HeadData)
{
byte b = bytesIn[0]; //获取一个byte
HeadData.typ = (byte)(b & 0xF); //低4位为类型
HeadData.tag = (b & 0xF0) >> 4; //高4位为tag,
if (HeadData.tag != 0xF) //如果tag为0xF 则下一个字段为tag
{
return(1);
}
HeadData.tag = bytesIn[1] & 0xFF;
return(2);
}
private static string GetFieldValue(ref byte[] bytesIn)
{
var retStr = "";
HeadDataStruct HeadData = new HeadDataStruct();
var len = readHead(bytesIn, ref HeadData);
bytesIn = bytesIn.Skip(len).ToArray();
switch (HeadData.typ)
{
case (byte)JceType.TYPE_BYTE:
{
retStr = bytesIn[0].ToString();
bytesIn = bytesIn.Skip(1).ToArray();
break;
}
case (byte)JceType.TYPE_SHORT:
{
retStr = BitConverter.ToInt16(bytesIn.Take(2).ToArray().Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(2).ToArray();
break;
}
case (byte)JceType.TYPE_INT:
{
retStr = BitConverter.ToInt32(bytesIn.Take(4).ToArray().Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(4).ToArray();
break;
}
case (byte)JceType.TYPE_LONG:
{
retStr = BitConverter.ToInt64(bytesIn.Take(8).ToArray().Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(8).ToArray();
break;
}
case (byte)JceType.TYPE_FLOAT:
{
retStr = BitConverter.ToSingle(bytesIn.Take(4).ToArray().Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(4).ToArray();
break;
}
case (byte)JceType.TYPE_DOUBLE:
{
retStr = BitConverter.ToDouble(bytesIn.Take(8).ToArray().Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(8).ToArray();
break;
}
case (byte)JceType.TYPE_STRING1:
{
len = bytesIn.Take(1).ToArray()[0];
bytesIn = bytesIn.Skip(1).ToArray();
if (len > 0)
{
retStr = Encoding.UTF8.GetString(bytesIn.Take(len).ToArray()).Replace("\0", "").Replace("\n", "").Replace("\r\n", "").Replace("\r", "").Replace("\b", "").Replace("\f", "").Replace("\v", "");
bytesIn = bytesIn.Skip(len).ToArray();
}
break;
}
case (byte)JceType.TYPE_STRING4:
{
len = bytesIn.Take(1).ToArray()[0];
bytesIn = bytesIn.Skip(1).ToArray();
if (len > 0)
{
retStr = Encoding.UTF8.GetString(bytesIn.Take(len).ToArray()).Replace("\0", "").Replace("\n", "").Replace("\r\n", "").Replace("\r", "").Replace("\b", "").Replace("\f", "").Replace("\v", "");
bytesIn = bytesIn.Skip(len).ToArray();
}
break;
}
case (byte)JceType.TYPE_MAP:
{
var count = 0;
HeadDataStruct HD = new HeadDataStruct();
bytesIn = SkipLength(bytesIn, ref count, ref HD);
retStr = DecodeMap(ref bytesIn, HeadData.tag, count).ToString();
break;
}
case (byte)JceType.TYPE_LIST:
{
var count = 0;
HeadDataStruct HD = new HeadDataStruct();
bytesIn = SkipLength(bytesIn, ref count, ref HD);
retStr = DecodeList(ref bytesIn, HeadData.tag, count);
break;
}
case (byte)JceType.TYPE_SIMPLE_LIST:
{
HeadDataStruct HD = new HeadDataStruct();
readHead(bytesIn, ref HD);
bytesIn = bytesIn.Skip(1).ToArray();
bytesIn = SkipLength(bytesIn, ref len, ref HD);
if (len > 0)
{
retStr = BitConverter.ToString(bytesIn.Take(len).ToArray()).Replace("-", "");
bytesIn = bytesIn.Skip(len).ToArray();
}
break;
}
case (byte)JceType.TYPE_STRUCT_BEGIN:
{
retStr = GetStuctValue(ref bytesIn);
break;
}
case (byte)JceType.TYPE_STRUCT_END:
{
break;
}
case (byte)JceType.TYPE_ZERO_TAG:
{
retStr = "0";
break;
}
}
return(retStr);
}
public static void DecodeSubJce(ref byte[] bytesIn)
{
byte[] jceData = null;
HeadDataStruct HeadData = new HeadDataStruct();
try
{
while (bytesIn.Length > 0)
{
var len = readHead(bytesIn, ref HeadData);
var Hex = bytesIn[0].ToString("x2").ToUpper();
bytesIn = bytesIn.Skip(len).ToArray();
var typ = HeadData.typ;
var tag = HeadData.tag;
switch (typ)
{
case (byte)JceType.TYPE_BYTE:
{
jceData = bytesIn.Take(1).ToArray();
bytesIn = bytesIn.Skip(1).ToArray();
break;
}
case (byte)JceType.TYPE_SHORT:
{
jceData = bytesIn.Take(2).ToArray();
bytesIn = bytesIn.Skip(2).ToArray();
break;
}
case (byte)JceType.TYPE_INT:
{
jceData = bytesIn.Take(4).ToArray();
bytesIn = bytesIn.Skip(4).ToArray();
break;
}
case (byte)JceType.TYPE_LONG:
{
jceData = bytesIn.Take(8).ToArray();
bytesIn = bytesIn.Skip(8).ToArray();
break;
}
case (byte)JceType.TYPE_FLOAT:
{
jceData = bytesIn.Take(4).ToArray();
bytesIn = bytesIn.Skip(4).ToArray();
break;
}
case (byte)JceType.TYPE_DOUBLE:
{
jceData = bytesIn.Take(8).ToArray();
bytesIn = bytesIn.Skip(8).ToArray();
break;
}
case (byte)JceType.TYPE_STRING1:
{
int jceDatalen = bytesIn.Take(1).ToArray()[0];
bytesIn = bytesIn.Skip(1).ToArray();
if (jceDatalen > 0)
{
if (bytesIn.Length < jceDatalen)
{
jceDatalen = bytesIn.Length;
}
jceData = bytesIn.Take(jceDatalen).ToArray();
bytesIn = bytesIn.Skip(jceDatalen).ToArray();
}
break;
}
case (byte)JceType.TYPE_STRING4:
{
var jceDatalen = BitConverter.ToInt32(bytesIn.Take(4).Reverse().ToArray(), 0);
bytesIn = bytesIn.Skip(4).ToArray();
if (jceDatalen > 0)
{
if (bytesIn.Length < jceDatalen)
{
jceDatalen = bytesIn.Length;
}
jceData = bytesIn.Take(jceDatalen).ToArray();
bytesIn = bytesIn.Skip(jceDatalen).ToArray();
}
break;
}
case (byte)JceType.TYPE_MAP:
{
var count = 0;
HeadDataStruct HD = new HeadDataStruct();
bytesIn = SkipLength(bytesIn, ref count, ref HD);
if (count > 0)
{
DecodeMap(ref bytesIn, tag, count);
}
break;
}
case (byte)JceType.TYPE_LIST:
{
var count = 0;
HeadDataStruct HD = new HeadDataStruct();
bytesIn = SkipLength(bytesIn, ref count, ref HD);
if (count > 0)
{
DecodeList(ref bytesIn, tag, count);
}
break;
}
case (byte)JceType.TYPE_STRUCT_BEGIN:
{
break;
}
case (byte)JceType.TYPE_STRUCT_END:
{
break;
}
case (byte)JceType.TYPE_ZERO_TAG:
{
break;
}
case (byte)JceType.TYPE_SIMPLE_LIST:
{
HeadDataStruct HD = new HeadDataStruct();
readHead(bytesIn, ref HD);
bytesIn = bytesIn.Skip(1).ToArray();
var jceDatalen = 0;
bytesIn = SkipLength(bytesIn, ref jceDatalen, ref HD);
if (jceDatalen > 0)
{
jceData = bytesIn.Take(jceDatalen).ToArray();
if (jceData[0] == (int)JceType.TYPE_STRUCT_BEGIN || jceData[0] == (int)JceType.TYPE_LIST || jceData[0] == (int)JceType.TYPE_SIMPLE_LIST || jceData[0] == (int)JceType.TYPE_MAP && jceData[1] == 0)
{
var tempBytes = bytesIn;
DecodeSubJce(ref tempBytes);
}
bytesIn = bytesIn.Skip(jceDatalen).ToArray();
}
break;
}
}
}
}
catch (Exception ex)
{
Debug.Print(ex.Message.ToString());
}
}
public static void DecodeJce(ref byte[] bytesIn)
{
string Value = null;
byte[] jceData = null;
HeadDataStruct HeadData = new HeadDataStruct();
try
{
while (bytesIn.Length > 0)
{
var len = readHead(bytesIn, ref HeadData);
var Hex = bytesIn[0].ToString("x2").ToUpper();
bytesIn = bytesIn.Skip(len).ToArray();
var typ = HeadData.typ;
var tag = HeadData.tag;
switch (typ)
{
case (byte)JceType.TYPE_BYTE:
{
jceData = bytesIn.Take(1).ToArray();
Value = jceData[0].ToString();
bytesIn = bytesIn.Skip(1).ToArray();
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicByte.Add(DicItem);
break;
}
case (byte)JceType.TYPE_SHORT:
{
jceData = bytesIn.Take(2).ToArray();
Value = BitConverter.ToInt16(jceData.Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(2).ToArray();
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicShort.Add(DicItem);
break;
}
case (byte)JceType.TYPE_INT:
{
jceData = bytesIn.Take(4).ToArray();
Value = BitConverter.ToInt32(jceData.Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(4).ToArray();
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicInt.Add(DicItem);
break;
}
case (byte)JceType.TYPE_LONG:
{
jceData = bytesIn.Take(8).ToArray();
Value = BitConverter.ToInt64(jceData.Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(8).ToArray();
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicLong.Add(DicItem);
break;
}
case (byte)JceType.TYPE_FLOAT:
{
jceData = bytesIn.Take(4).ToArray();
Value = BitConverter.ToSingle(jceData.Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(4).ToArray();
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicSingle.Add(DicItem);
break;
}
case (byte)JceType.TYPE_DOUBLE:
{
jceData = bytesIn.Take(8).ToArray();
Value = BitConverter.ToDouble(jceData.Reverse().ToArray(), 0).ToString();
bytesIn = bytesIn.Skip(8).ToArray();
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicDouble.Add(DicItem);
break;
}
case (byte)JceType.TYPE_STRING1:
{
int jceDatalen = bytesIn.Take(1).ToArray()[0];
bytesIn = bytesIn.Skip(1).ToArray();
if (jceDatalen > 0)
{
if (bytesIn.Length < jceDatalen)
{
jceDatalen = bytesIn.Length;
}
jceData = bytesIn.Take(jceDatalen).ToArray();
Value = Encoding.UTF8.GetString(jceData).Replace("\0", "").Replace("\n", "").Replace("\r\n", "").Replace("\r", "").Replace("\b", "").Replace("\f", "").Replace("\v", "");
bytesIn = bytesIn.Skip(jceDatalen).ToArray();
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicString.Add(DicItem);
}
break;
}
case (byte)JceType.TYPE_STRING4:
{
var jceDatalen = BitConverter.ToInt32(bytesIn.Take(4).Reverse().ToArray(), 0);
bytesIn = bytesIn.Skip(4).ToArray();
if (jceDatalen > 0)
{
if (bytesIn.Length < jceDatalen)
{
jceDatalen = bytesIn.Length;
}
jceData = bytesIn.Take(jceDatalen).ToArray();
Value = Encoding.UTF8.GetString(jceData).Replace("\0", "").Replace("\n", "").Replace("\r\n", "").Replace("\r", "").Replace("\b", "").Replace("\f", "").Replace("\v", "");
bytesIn = bytesIn.Skip(jceDatalen).ToArray();
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicString.Add(DicItem);
}
break;
}
case (byte)JceType.TYPE_MAP:
{
var count = 0;
HeadDataStruct HD = new HeadDataStruct();
bytesIn = SkipLength(bytesIn, ref count, ref HD);
if (count > 0)
{
DecodeMap(ref bytesIn, tag, count);
}
break;
}
case (byte)JceType.TYPE_LIST:
{
var count = 0;
HeadDataStruct HD = new HeadDataStruct();
bytesIn = SkipLength(bytesIn, ref count, ref HD);
if (count > 0)
{
DecodeList(ref bytesIn, tag, count);
}
break;
}
case (byte)JceType.TYPE_STRUCT_BEGIN:
{
break;
}
case (byte)JceType.TYPE_STRUCT_END:
{
break;
}
case (byte)JceType.TYPE_ZERO_TAG:
{
break;
}
case (byte)JceType.TYPE_SIMPLE_LIST:
{
HeadDataStruct HD = new HeadDataStruct();
readHead(bytesIn, ref HD);
bytesIn = bytesIn.Skip(1).ToArray();
var jceDatalen = 0;
bytesIn = SkipLength(bytesIn, ref jceDatalen, ref HD);
if (jceDatalen > 0)
{
jceData = bytesIn.Take(jceDatalen).ToArray();
Value = BitConverter.ToString(jceData).Replace("-", "");
Dictionary <string, string> DicItem = new Dictionary <string, string>()
{
{ tag.ToString(), Value }
};
DicSimpleList.Add(DicItem);
DecodeSimpleList(ref bytesIn, tag, jceDatalen);
}
break;
}
}
}
}
catch (Exception ex)
{
Debug.Print(ex.Message.ToString());
}
}
public static TreeNodeStruct QuickDecodeJce(string RootKey, TreeNodeStruct NodeStruct)
{
var NodeList = new List <TreeNode>();
if (!string.IsNullOrEmpty(RootKey))
{
NodeList.Add(NodeStruct.CurrentNode);
var NodeCollection = NodeStruct.CurrentNode.Nodes;
TreeNode[] Nodes = NodeCollection.Find(RootKey, true);
if (Nodes.Count() > 0)
{
NodeStruct.CurrentNode = Nodes[0];
}
}
///////////貌似得缓存一下，不然有些分叉出现错位现象，这个对大型数据解析的速度影响很大，慢了很多，不知道该怎么处理
///Thread.Sleep(20);
var now = DateTime.Now;
while (DateTime.Now < now.AddMilliseconds(15))
{
}
///////////
string subNode = null;
byte[] jceData = null;
HeadDataStruct HeadData = new HeadDataStruct();
try
{
while (NodeStruct.BytesIn.Length > 0)
{
var len = readHead(NodeStruct.BytesIn, ref HeadData);
var Hex = NodeStruct.BytesIn[0].ToString("x2").ToUpper();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(len).ToArray();
var typ = HeadData.typ;
var tag = HeadData.tag;
switch ((int)typ)
{
case (int)JceType.TYPE_BYTE:
{
jceData = NodeStruct.BytesIn.Take(1).ToArray();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(1).ToArray();
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (Byte) Value=" + jceData[0].ToString() + " Hex=" + BitConverter.ToString(jceData).Replace("-", " ");
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_SHORT:
{
jceData = NodeStruct.BytesIn.Take(2).ToArray();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(2).ToArray();
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (Short) Value=" + BitConverter.ToInt16(jceData.Reverse().ToArray(), 0).ToString() + " Hex=" + BitConverter.ToString(jceData).Replace("-", " ");
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_INT:
{
jceData = NodeStruct.BytesIn.Take(4).ToArray();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(4).ToArray();
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (Int) Value=" + BitConverter.ToInt32(jceData.Reverse().ToArray(), 0).ToString() + " Hex=" + BitConverter.ToString(jceData).Replace("-", " ");
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_LONG:
{
jceData = NodeStruct.BytesIn.Take(8).ToArray();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(8).ToArray();
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (Long) Value=" + BitConverter.ToInt64(jceData.Reverse().ToArray(), 0).ToString() + " Hex=" + BitConverter.ToString(jceData).Replace("-", " ");
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_FLOAT:
{
jceData = NodeStruct.BytesIn.Take(4).ToArray();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(4).ToArray();
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (Single) Value=" + BitConverter.ToSingle(jceData.Reverse().ToArray(), 0).ToString() + " Hex=" + BitConverter.ToString(jceData).Replace("-", " ");
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_DOUBLE:
{
jceData = NodeStruct.BytesIn.Take(8).ToArray();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(8).ToArray();
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (Double) Value=" + BitConverter.ToDouble(jceData.Reverse().ToArray(), 0).ToString() + " Hex=" + BitConverter.ToString(jceData).Replace("-", " ");
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_STRING1:
{
var jceDatalen = int.Parse(Convert.ToString(NodeStruct.BytesIn.Take(1).ToArray()[0]));
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(1).ToArray();
if (jceDatalen > 0)
{
if (NodeStruct.BytesIn.Length < jceDatalen)
{
jceDatalen = NodeStruct.BytesIn.Length;
}
jceData = NodeStruct.BytesIn.Take(jceDatalen).ToArray();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(jceDatalen).ToArray();
var str = Encoding.UTF8.GetString(jceData).Replace("\0", "").Replace("\n", "").Replace("\r\n", "").Replace("\r", "").Replace("\b", "").Replace("\f", "").Replace("\v", "");
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (String) Length=" + str.Length.ToString() + " UTF8=" + str;
}
else
{
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (LongString) Length=0 Hex=00";
}
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_STRING4:
{
var jceDatalen = BitConverter.ToInt32(NodeStruct.BytesIn.Take(4).Reverse().ToArray(), 0);
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(4).ToArray();
if (jceDatalen > 0)
{
if (NodeStruct.BytesIn.Length < jceDatalen)
{
jceDatalen = NodeStruct.BytesIn.Length;
}
jceData = NodeStruct.BytesIn.Take(jceDatalen).ToArray();
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(jceDatalen).ToArray();
var str = Encoding.UTF8.GetString(jceData).Replace("\0", "").Replace("\n", "").Replace("\r\n", "").Replace("\r", "").Replace("\b", "").Replace("\f", "").Replace("\v", "");
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (LongString) Length=" + str.Length.ToString() + " UTF8=" + str;
}
else
{
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (LongString) Length=0 Hex=00";
}
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_MAP:
{
var count = 0;
HeadDataStruct HD = new HeadDataStruct();
NodeStruct.BytesIn = SkipLength(NodeStruct.BytesIn, ref count, ref HD);
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (Map) Count=" + count.ToString();
if (count > 0)
{
MapCount.Add(count);
MapKey = false;
var RandKey = new Random().Next().ToString();
NodeStruct.CurrentNode.Nodes.Add(subNode + RandKey, subNode);
NodeStruct = QuickDecodeJce(subNode + RandKey, NodeStruct);
}
else
{
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
}
break;
}
case (int)JceType.TYPE_LIST:
{
var count = 0;
HeadDataStruct HD = new HeadDataStruct();
NodeStruct.BytesIn = SkipLength(NodeStruct.BytesIn, ref count, ref HD);
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (List) Count=" + count.ToString();
if (count > 0)
{
ListCount.Add(count);
var RandKey = new Random().Next().ToString();
NodeStruct.CurrentNode.Nodes.Add(subNode + RandKey, subNode);
NodeStruct = QuickDecodeJce(subNode + RandKey, NodeStruct);
}
else
{
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
}
break;
}
case (int)JceType.TYPE_STRUCT_BEGIN:
{
if (tag.ToString() != "0")
{
subNode = "Field #" + tag.ToString() + " [STRUCT_BEGIN]";
}
else
{
subNode = "[STRUCT_BEGIN]";
}
var RandKey = new Random().Next().ToString();
NodeStruct.CurrentNode.Nodes.Add(subNode + RandKey, subNode);
NodeStruct = QuickDecodeJce(subNode + RandKey, NodeStruct);
NodeStruct.CurrentNode.Nodes.Add("STRUCT_END");
break;
}
case (int)JceType.TYPE_STRUCT_END:
{
goto ExitLabel1;
}
case (int)JceType.TYPE_ZERO_TAG:
{
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (Zero) Value=0";
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
break;
}
case (int)JceType.TYPE_SIMPLE_LIST:
{
HeadDataStruct HD = new HeadDataStruct();
readHead(NodeStruct.BytesIn, ref HD);
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(1).ToArray();
var jceDatalen = 0;
NodeStruct.BytesIn = SkipLength(NodeStruct.BytesIn, ref jceDatalen, ref HD);
if (jceDatalen > 0)
{
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (SimpleList) Length=" + jceDatalen.ToString();
jceData = NodeStruct.BytesIn.Take(jceDatalen).ToArray();
if (jceData[0] == (byte)JceType.TYPE_STRUCT_BEGIN || jceData[0] == (byte)JceType.TYPE_LIST || jceData[0] == (byte)JceType.TYPE_SIMPLE_LIST || (jceData[0] == (byte)JceType.TYPE_MAP && jceData[1] == 0))
{
var RandKey = new Random().Next().ToString();
NodeStruct.CurrentNode.Nodes.Add(subNode + RandKey, subNode);
var DataRemain = NodeStruct.BytesIn.Skip(jceDatalen).ToArray();
NodeStruct.BytesIn = jceData;
QuickDecodeJce(subNode + RandKey, NodeStruct);
NodeStruct.BytesIn = DataRemain;
}
else
{
NodeStruct.BytesIn = NodeStruct.BytesIn.Skip(jceDatalen).ToArray();
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (SimpleList) Length=" + jceData.Length.ToString() + " Hex=" + BitConverter.ToString(jceData).Replace("-", "");
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
}
}
else
{
subNode = "Field #" + tag.ToString() + " [" + Hex + "] (SimpleList) Length=0";
NodeStruct.CurrentNode.Nodes.Add(new TreeNode(subNode));
}
MapKey = true;
break;
}
}
if (CheckLeaveStatus(NodeStruct) == true)
{
break;
}
}
ExitLabel1 :;
}
catch (Exception ex)
{
Console.WriteLine(ex.Message.ToString());
}
if (!string.IsNullOrEmpty(RootKey))
{
TreeNode Parent = NodeStruct.CurrentNode.Parent;
if (Parent != null)
{
NodeStruct.CurrentNode = Parent;
}
}
return(NodeStruct);
}
