/// <summary> /// Create a new DerInteger for the value. /// </summary> /// /// <param name="integer">The value to encode.</param> public DerInteger(int integer) : base(net.named_data.jndn.encoding.der.DerNodeType.Integer) { if (integer < 0) { throw new DerEncodingException( "DerInteger: Negative integers are not currently supported"); } // Convert the integer to bytes the easy/slow way. DynamicByteBuffer temp = new DynamicByteBuffer(10); // We encode backwards from the back. temp.position(temp.limit()); while (true) { temp.ensuredPutFromBack((byte)(integer & 0xff)); integer >>= 8; if (integer <= 0) { // We check for 0 at the end so we encode one byte if it is 0. break; } } if ((((int)temp.buffer().get(temp.position())) & 0xff) >= 0x80) { // Make it a non-negative integer. temp.ensuredPutFromBack((byte)0); } payload_.ensuredPut(temp.buffer().slice()); encodeHeader(payload_.position()); }
/// <summary> /// Compute the encoding for one part of an OID, where values greater than 128 must be encoded as multiple bytes. /// </summary> /// /// <param name="value">A component of an OID.</param> /// <returns>The encoded buffer.</returns> public static ByteBuffer encode128(int value_ren) { int mask = (1 << 7) - 1; DynamicByteBuffer outBytes = new DynamicByteBuffer(10); // We encode backwards from the back. outBytes.position(outBytes.limit()); if (value_ren < 128) { outBytes.ensuredPutFromBack((byte)(value_ren & mask)); } else { outBytes.ensuredPutFromBack((byte)(value_ren & mask)); value_ren >>= 7; while (value_ren != 0) { outBytes.ensuredPutFromBack((byte)((value_ren & mask) | (1 << 7))); value_ren >>= 7; } } return(outBytes.buffer().slice()); }
/// <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(); }
/// <summary> /// Create a new TlvEncoder with a default DynamicByteBuffer. /// When done, you should call getOutput(). /// </summary> /// public TlvEncoder() { output_ = new DynamicByteBuffer(16); // We will start encoding from the back. output_.position(output_.limit()); }
/// <summary> /// Create a new TlvEncoder to use a DynamicByteBuffer with the initialCapacity. /// When done, you should call getOutput(). /// </summary> /// /// <param name="initialCapacity">The initial capacity of buffer().</param> public TlvEncoder(int initialCapacity) { output_ = new DynamicByteBuffer(initialCapacity); // We will start encoding from the back. output_.position(output_.limit()); }