protected static long ResetBranchDataLength(Asn1Node node)
{
long num = 0;
if (node.ChildNodeCount < 1L)
{
if (node.data != null)
{
num += (long)node.data.Length;
}
}
else
{
for (int index = 0; (long)index < node.ChildNodeCount; ++index)
{
num += Asn1Node.ResetBranchDataLength(node.GetChildNode(index));
}
}
node.dataLength = num;
if (node.tag == (byte)3)
{
++node.dataLength;
}
Asn1Node.ResetDataLengthFieldWidth(node);
return(node.dataLength + 1L + node.lengthFieldBytes);
}
public Asn1Node GetDescendantNodeByPath(string nodePath)
{
Asn1Node asn1Node = this;
if (nodePath == null)
{
return(asn1Node);
}
nodePath = nodePath.TrimEnd().TrimStart();
if (nodePath.Length < 1)
{
return(asn1Node);
}
string[] strArray = nodePath.Split('/');
try
{
for (int index = 1; index < strArray.Length; ++index)
{
asn1Node = asn1Node.GetChildNode(Convert.ToInt32(strArray[index]));
}
}
catch
{
asn1Node = (Asn1Node)null;
}
return(asn1Node);
}
public static long GetDescendantNodeCount(Asn1Node node)
{
long num = 0L + node.ChildNodeCount;
for (int index = 0; (long)index < node.ChildNodeCount; ++index)
{
num += Asn1Node.GetDescendantNodeCount(node.GetChildNode(index));
}
return(num);
}
protected void ResetChildNodePar(Asn1Node xNode, long subOffset)
{
if (xNode.tag == (byte)3)
{
++subOffset;
}
for (int index = 0; (long)index < xNode.ChildNodeCount; ++index)
{
Asn1Node childNode = xNode.GetChildNode(index);
childNode.parentNode = xNode;
childNode.dataOffset = subOffset;
childNode.deepness = xNode.deepness + 1L;
childNode.path = xNode.path + (object)'/' + index.ToString();
subOffset += 1L + childNode.lengthFieldBytes;
this.ResetChildNodePar(childNode, subOffset);
subOffset += childNode.dataLength;
}
}
public static Asn1Node GetDecendantNodeByOid(string oid, Asn1Node startNode)
{
Asn1Node asn1Node = (Asn1Node)null;
Oid oid1 = new Oid();
for (int index = 0; (long)index < startNode.ChildNodeCount; ++index)
{
Asn1Node childNode = startNode.GetChildNode(index);
if (((int)childNode.tag & 31) == 6 && oid == oid1.Decode(childNode.Data))
{
asn1Node = childNode;
break;
}
asn1Node = Asn1Node.GetDecendantNodeByOid(oid, childNode);
if (asn1Node != null)
{
break;
}
}
return(asn1Node);
}
/// <summary>
/// Retrieve all the node count in the node subtree.
/// </summary>
/// <param name="node">starting node.</param>
/// <returns>long integer node count in the node subtree.</returns>
public static long GetDescendantNodeCount(Asn1Node node)
{
long count =0;
count += node.ChildNodeCount;
for (int i=0; i<node.ChildNodeCount; i++)
{
count += GetDescendantNodeCount(node.GetChildNode(i));
}
return count;
}
/// <summary>
/// Recursively set all the child parameters, except dataLength.
/// dataLength is set by ResetBranchDataLength.
/// </summary>
/// <param name="xNode">Starting node.</param>
/// <param name="subOffset">Starting node offset.</param>
protected void ResetChildNodePar(Asn1Node xNode, long subOffset)
{
int i;
if (xNode.tag == Asn1Tag.BIT_STRING)
{
subOffset++;
}
Asn1Node tempNode;
for (i=0; i<xNode.ChildNodeCount; i++)
{
tempNode = xNode.GetChildNode(i);
tempNode.parentNode = xNode;
tempNode.dataOffset = subOffset;
tempNode.deepness = xNode.deepness + 1;
tempNode.path = xNode.path + '/' + i.ToString();
subOffset += TagLength + tempNode.lengthFieldBytes;
ResetChildNodePar(tempNode, subOffset);
subOffset += tempNode.dataLength;
}
}
/// <summary>
/// Recursively set all the node data length.
/// </summary>
/// <param name="node"></param>
/// <returns>node data length.</returns>
protected static long ResetBranchDataLength(Asn1Node node)
{
long retval = 0;
long childDataLength = 0;
if (node.ChildNodeCount < 1)
{
if (node.data != null)
childDataLength += node.data.Length;
}
else
{
for (int i=0; i<node.ChildNodeCount; i++)
{
childDataLength += ResetBranchDataLength(node.GetChildNode(i));
}
}
node.dataLength = childDataLength;
if (node.tag == Asn1Tag.BIT_STRING)
node.dataLength += BitStringUnusedFiledLength;
ResetDataLengthFieldWidth(node);
retval = node.dataLength + TagLength + node.lengthFieldBytes;
return retval;
}
/// <summary>
/// Get node by OID.
/// </summary>
/// <param name="oid">OID.</param>
/// <param name="startNode">Starting node.</param>
/// <returns>Null or Asn1Node.</returns>
static public Asn1Node GetDecendantNodeByOid(string oid, Asn1Node startNode)
{
Asn1Node retval = null;
Oid xoid = new Oid();
for (int i = 0; i<startNode.ChildNodeCount; i++)
{
Asn1Node childNode = startNode.GetChildNode(i);
int tmpTag = childNode.tag & Asn1Tag.TAG_MASK;
if (tmpTag == Asn1Tag.OBJECT_IDENTIFIER)
{
if (oid == xoid.Decode(childNode.Data))
{
retval = childNode;
break;
}
}
retval = GetDecendantNodeByOid(oid, childNode);
if (retval != null) break;
}
return retval;
}