/// <summary>
/// Get the raw data encoding for this node.
/// </summary>
///
/// <returns>The raw data encoding.</returns>
public virtual Blob encode()
{
DynamicByteBuffer buffer = new DynamicByteBuffer(getSize());
buffer.ensuredPut(header_);
buffer.ensuredPut(payload_.flippedBuffer());
return(new Blob(buffer.flippedBuffer(), false));
}
/// <summary>
/// Encode a sequence of integers into an OID object and set the payload.
/// </summary>
///
/// <param name="value">The array of integers.</param>
public void prepareEncoding(int[] value_ren)
{
int firstNumber = 0;
if (value_ren.Length == 0)
{
throw new DerEncodingException("No integer in OID");
}
else
{
if (value_ren[0] >= 0 && value_ren[0] <= 2)
{
firstNumber = value_ren[0] * 40;
}
else
{
throw new DerEncodingException(
"First integer in OID is out of range");
}
}
if (value_ren.Length >= 2)
{
if (value_ren[1] >= 0 && value_ren[1] <= 39)
{
firstNumber += value_ren[1];
}
else
{
throw new DerEncodingException(
"Second integer in OID is out of range");
}
}
DynamicByteBuffer encodedBuffer = new DynamicByteBuffer(10);
encodedBuffer.ensuredPut(encode128(firstNumber));
if (value_ren.Length > 2)
{
for (int i = 2; i < value_ren.Length; ++i)
{
encodedBuffer.ensuredPut(encode128(value_ren[i]));
}
}
encodeHeader(encodedBuffer.position());
payload_.ensuredPut(encodedBuffer.flippedBuffer());
}
/// <summary>
/// Override the base encode to return raw data encoding for this node and
/// its children
/// </summary>
///
/// <returns>The raw data encoding.</returns>
public override Blob encode()
{
DynamicByteBuffer temp = new DynamicByteBuffer(10);
updateSize();
encodeHeader(size_);
temp.ensuredPut(header_);
for (int i = 0; i < nodeList_.Count; ++i)
{
DerNode n = nodeList_[i];
Blob encodedChild = n.encode();
temp.ensuredPut(encodedChild.buf());
}
return(new Blob(temp.flippedBuffer(), false));
}
/// <summary>
/// Extract the header from an input buffer and return the size.
/// </summary>
///
/// <param name="inputBuf">position.</param>
/// <param name="startIdx">The offset into the buffer.</param>
/// <returns>The parsed size in the header.</returns>
protected internal int decodeHeader(ByteBuffer inputBuf, int startIdx)
{
int idx = startIdx;
int nodeType = ((int)inputBuf.get(idx)) & 0xff;
idx += 1;
nodeType_ = nodeType;
int sizeLen = ((int)inputBuf.get(idx)) & 0xff;
idx += 1;
DynamicByteBuffer header = new DynamicByteBuffer(10);
header.ensuredPut((byte)nodeType);
header.ensuredPut((byte)sizeLen);
int size = sizeLen;
bool isLongFormat = (sizeLen & (1 << 7)) != 0;
if (isLongFormat)
{
int lenCount = sizeLen & ((1 << 7) - 1);
size = 0;
while (lenCount > 0)
{
if (inputBuf.limit() <= idx)
{
throw new DerDecodingException(
"DerNode.parse: The input length is too small");
}
byte b = inputBuf.get(idx);
idx += 1;
header.ensuredPut(b);
size = 256 * size + (((int)b) & 0xff);
lenCount -= 1;
}
}
header_ = header.flippedBuffer();
return(size);
}
/// <summary>
/// Encode the given size and update the header.
/// </summary>
///
/// <param name="size">The payload size to encode.</param>
protected internal void encodeHeader(int size)
{
DynamicByteBuffer buffer = new DynamicByteBuffer(10);
buffer.ensuredPut((byte)nodeType_);
if (size < 0)
{
// We don't expect this to happen since this is a protected method and
// always called with the non-negative size() of some buffer.
throw new Exception("encodeHeader: DER object has negative length");
}
else if (size <= 127)
{
buffer.ensuredPut((byte)(size & 0xff));
}
else
{
DynamicByteBuffer tempBuf = new DynamicByteBuffer(10);
// We encode backwards from the back.
tempBuf.position(tempBuf.limit());
int val = size;
int n = 0;
while (val != 0)
{
tempBuf.ensuredPutFromBack((byte)(val & 0xff));
val >>= 8;
n += 1;
}
tempBuf.ensuredPutFromBack((byte)(((1 << 7) | n) & 0xff));
buffer.ensuredPut(tempBuf.buffer());
}
header_ = buffer.flippedBuffer();
}
