public void Write(BerTag tag, bool value) { WriteOuterHeader(tag, 3); BerEncoding.EncodeTag(_output, new BerTag(BerType.Boolean)); BerEncoding.EncodeLength(_output, 1); BerEncoding.EncodeBoolean(_output, value); }
internal override int Update() { var output = new BerMemoryOutput(); var implicitTag = new BerTag(BerClass.Universal, BerTypeNumber, true); var childrenLength = 0; foreach (var child in this) { childrenLength += child.IsDirty ? child.Update() : child.EncodedLength; } BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, BerDefinitions.IndefiniteLength); BerEncoding.EncodeTag(output, implicitTag); BerEncoding.EncodeLength(output, BerDefinitions.IndefiniteLength); _encodedFrameHeader = output.ToArray(); EncodedLength = childrenLength + _encodedFrameHeader.Length + BerEncoding.IndefiniteLengthTerminator.Length; return(EncodedLength); }
/// <summary> /// Pre-encodes the BER header and returns the byte length of the encoded node. /// Overridden to recursively pre-encode all descendants. /// </summary> /// <returns>The length of the encoded node.</returns> internal override int Update() { var output = new BerMemoryOutput(); var implicitTag = BerType.IsApplicationDefined(BerTypeNumber) ? new BerTag(BerClass.Application, BerTypeNumber & ~BerType.ApplicationFlag, true) : new BerTag(BerClass.Universal, BerTypeNumber, true); _childrenLength = 0; foreach (var child in _nodes) { _childrenLength += child.IsDirty ? child.Update() : child.EncodedLength; } var implicitLength = _childrenLength + BerEncoding.GetHeaderLength(implicitTag, _childrenLength); BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, implicitLength); BerEncoding.EncodeTag(output, implicitTag); BerEncoding.EncodeLength(output, _childrenLength); _encodedHeader = output.ToArray(); EncodedLength = _childrenLength + _encodedHeader.Length; return(EncodedLength); }
internal override void EncodeOverride(IBerOutput output) { Debug.Assert(Value != null); base.EncodeOverride(output); BerEncoding.EncodeByteArray(output, Value); }
internal override void EncodeOverride(IBerOutput output) { Debug.Assert(Value != null); base.EncodeOverride(output); BerEncoding.EncodeObjectIdentifier(output, Value); }
internal override void EncodeOverride(IBerOutput output) { Debug.Assert(Value != null); base.EncodeOverride(output); BerEncoding.EncodeRelativeOid(output, Value); }
public void Write(BerTag tag, long value) { var valueLength = BerEncoding.GetLongLength(value); WriteOuterHeader(tag, valueLength + 2); BerEncoding.EncodeTag(_output, new BerTag(BerType.Integer)); BerEncoding.EncodeLength(_output, valueLength); BerEncoding.EncodeLong(_output, value, (int)valueLength); }
public void Write(BerTag tag, byte[] value) { var valueLength = value.Length; var innerTag = new BerTag(BerType.OctetString); WriteOuterHeader(tag, valueLength + BerEncoding.GetHeaderLength(innerTag, valueLength)); BerEncoding.EncodeTag(_output, innerTag); BerEncoding.EncodeLength(_output, valueLength); _output.WriteBytes(value); }
public void Write(BerTag tag, double value) { var valueOutput = new BerMemoryOutput(); var valueLength = BerEncoding.EncodeReal(valueOutput, value); WriteOuterHeader(tag, valueLength + 2); BerEncoding.EncodeTag(_output, new BerTag(BerType.Real)); BerEncoding.EncodeLength(_output, valueLength); _output.WriteBytes(valueOutput.Memory); }
public void WriteRelativeOid(BerTag tag, int[] value) { var innerTag = new BerTag(BerType.RelativeOid); var valueLength = BerEncoding.GetRelativeOidLength(value); WriteOuterHeader(tag, valueLength + BerEncoding.GetHeaderLength(innerTag, valueLength)); BerEncoding.EncodeTag(_output, innerTag); BerEncoding.EncodeLength(_output, valueLength); BerEncoding.EncodeRelativeOid(_output, value); }
public void Write(BerTag tag, string value) { var valueOutput = new BerMemoryOutput(); var valueLength = BerEncoding.EncodeUtf8String(valueOutput, value); var innerTag = new BerTag(BerType.UTF8String); WriteOuterHeader(tag, valueLength + BerEncoding.GetHeaderLength(innerTag, valueLength)); BerEncoding.EncodeTag(_output, innerTag); BerEncoding.EncodeLength(_output, valueLength); _output.WriteBytes(valueOutput.Memory); }
internal override int Update() { var output = new BerMemoryOutput(); BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, 2); BerEncoding.EncodeTag(output, new BerTag(BerTypeNumber)); BerEncoding.EncodeLength(output, 0); Encoded = output.ToArray(); EncodedLength = Encoded.Length; return(EncodedLength); }
void Test_Real2() { var encoded = new byte[] { 0xC0, 0x04, 0xDF }; var input = new BerMemoryInput(encoded); var decoded = BerEncoding.DecodeReal(input, encoded.Length); Console.WriteLine("decoded={0}", decoded); var output = new BerMemoryOutput(); var reencoded = BerEncoding.EncodeReal(output, decoded); var bytes = output.ToArray(); Console.WriteLine("reencoded={0}", BytesToString(bytes)); }
void Test_Real() { var values = new[] { 32.1, 32.125, 32.123, 100, 200, 300, -1000, 5.5005005, 777777777.123456789 }; foreach (var value in values) { var output = new BerMemoryOutput(); BerEncoding.EncodeReal(output, value); var input = new BerMemoryInput(output.Memory); var decodedValue = BerEncoding.DecodeReal(input, output.Length); Console.WriteLine("value={0} decoded={1}", value, decodedValue); } }
/// <summary> /// Pre-encodes the BER header and returns the byte length of the encoded node. /// Overriden to encode the entire TLTLV /// </summary> /// <returns>The length of the encoded node.</returns> internal override int Update() { var output = new BerMemoryOutput(); var valueLength = BerEncoding.GetLongLength(Value); BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, valueLength + 2); BerEncoding.EncodeTag(output, new BerTag(BerType.Integer)); BerEncoding.EncodeLength(output, valueLength); BerEncoding.EncodeLong(output, Value, valueLength); Encoded = output.ToArray(); EncodedLength = Encoded.Length; return(EncodedLength); }
/// <summary> /// Pre-encodes the BER header and returns the byte length of the encoded node. /// Overriden to encode the entire TLTLV /// </summary> /// <returns>The length of the encoded node.</returns> internal override int Update() { var output = new BerMemoryOutput(); BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, 3); BerEncoding.EncodeTag(output, new BerTag(BerType.Boolean)); BerEncoding.EncodeLength(output, 1); BerEncoding.EncodeBoolean(output, Value); Encoded = output.ToArray(); EncodedLength = Encoded.Length; return(EncodedLength); }
/// <summary> /// Pre-encodes the BER header and returns the byte length of the encoded node. /// Overriden to encode the entire TLTLV /// </summary> /// <returns>The length of the encoded node.</returns> internal override int Update() { var output = new BerMemoryOutput(); var tagImplicit = new BerTag(BerType.RelativeOid); var valueLength = BerEncoding.GetRelativeOidLength(Value); var implicitLength = valueLength + BerEncoding.GetHeaderLength(tagImplicit, valueLength); BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, implicitLength); BerEncoding.EncodeTag(output, tagImplicit); BerEncoding.EncodeLength(output, valueLength); Encoded = output.ToArray(); EncodedLength = valueLength + Encoded.Length; return(EncodedLength); }
/// <summary> /// Pre-encodes the BER header and returns the byte length of the encoded node. /// Overriden to encode the entire TLTLV /// </summary> /// <returns>The length of the encoded node.</returns> internal override int Update() { var output = new BerMemoryOutput(); var arrayLength = Value.Length; var tagImplicit = new BerTag(BerType.OctetString); var implicitLength = (arrayLength + BerEncoding.GetHeaderLength(tagImplicit, arrayLength)); BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, implicitLength); BerEncoding.EncodeTag(output, tagImplicit); BerEncoding.EncodeLength(output, arrayLength); Encoded = output.ToArray(); EncodedLength = arrayLength + Encoded.Length; return(EncodedLength); }
/// <summary> /// Pre-encodes the BER header and returns the byte length of the encoded node. /// </summary> /// <returns>The length of the encoded node.</returns> internal override int Update() { var output = new BerMemoryOutput(); var stringLength = BerEncoding.GetUtf8StringLength(Value); var tagImplicit = new BerTag(BerType.UTF8String); var implicitLength = (stringLength + BerEncoding.GetHeaderLength(tagImplicit, stringLength)); BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, implicitLength); BerEncoding.EncodeTag(output, tagImplicit); BerEncoding.EncodeLength(output, stringLength); Encoded = output.ToArray(); EncodedLength = stringLength + Encoded.Length; return(EncodedLength); }
/// <summary> /// Pre-encodes the BER header and returns the byte length of the encoded node. /// Overriden to encode the entire TLTLV /// </summary> /// <returns>The length of the encoded node.</returns> internal override int Update() { var output = new BerMemoryOutput(); int tagLength, innerLength = 0, valueLength; tagLength = BerEncoding.EncodeTag(output, Tag.ToContainer()); BerEncoding.EncodeLength(output, 0); innerLength += BerEncoding.EncodeTag(output, new BerTag(BerType.Real)); innerLength += BerEncoding.EncodeLength(output, 0); innerLength += valueLength = BerEncoding.EncodeReal(output, Value); Encoded = output.ToArray(); EncodedLength = Encoded.Length; Encoded[tagLength] = (byte)innerLength; // fix outer length Encoded[tagLength + 2] = (byte)valueLength; // fix inner length return(EncodedLength); }
bool ReadByte_Tag(byte b) { if (b == 0 && _bytesRead == 0) { ResetState(DecodeState.Terminator); return(false); } if (_bytesRead > 12) { ThrowError(103, "Number of tag octets out of bounds"); } if (_bytesRead == 0 && (b & 0x1F) != 0x1F || _bytesRead > 0 && (b & 0x80) == 0) { var input = new BerMemoryInput(_buffer); if (Tag.IsZero) { // no outer tag read yet -> read outer tag var tag = BerEncoding.DecodeTag(input); if (tag.Class == BerClass.Universal) { ThrowError(107, "Universal outer tag encountered"); } if (tag.IsContainer == false) { ThrowError(108, "Primitive outer tag encountered"); } Tag = tag.ToPrimitive(); // clear container flag } else { // outer tag already read -> read inner tag (type tag) var typeTag = BerEncoding.DecodeTag(input); var type = typeTag.NumberAsType; if (BerType.IsApplicationDefined(type) == false) { if (typeTag.Class != BerClass.Universal) { ThrowError(110, "Non-universal inner tag encountered"); } if (type == 0 || type >= BerType.LastUniversal) { ThrowError(109, "Invalid BER type encountered"); } } IsContainer = typeTag.IsContainer; Type = type; } ResetState(DecodeState.Length); return(false); } _bytesRead++; return(false); }
void WriteOuterHeader(BerTag tag, int length) { BerEncoding.EncodeTag(_output, tag.ToContainer()); BerEncoding.EncodeLength(_output, length); }
public void WriteContainerBegin(BerTag tag, uint type) { WriteOuterHeader(tag, BerDefinitions.IndefiniteLength); BerEncoding.EncodeTag(_output, new BerTag(type, true)); BerEncoding.EncodeLength(_output, BerDefinitions.IndefiniteLength); }
/// <summary> /// Read the next TLTLV and publishes information like <see cref="BerLib.BerReaderBase.Tag" />, /// <see cref="BerLib.BerReaderBase.Length" />, <see cref="BerLib.BerReaderBase.Type" /> and /// <see cref="BerLib.BerReaderBase.IsContainer" />. /// Use one of the Get() functions of BerLib.BerReaderBase to retrieve the Value. /// </summary> /// <returns>True if a valid TLTLV has been read, otherwise false.</returns> public bool Read() { Debug.Assert(_input != null); var typeTag = BerTag.Zero; DisposeCurrentTlv(); if (_parentReader != null && // non top-level read? this.Eof) { HandleEof(); return(false); } Tag = BerEncoding.DecodeTag(this); if (Tag.IsZero) { // terminator of indefinite length field: 4 zeros (outer length AND inner length must be indefinite if (ReadByte() == 0 && ReadByte() == 0 && ReadByte() == 0) { HandleEof(); return(false); } else { ThrowError(10, "Invalid zero tag: 0x00"); } } OuterLength = BerEncoding.DecodeLength(this); if (OuterLength == 0) { ThrowError(13, "Zero outer length encountered"); } if (Tag.IsContainer && Tag.Class != BerClass.Universal) { typeTag = BerEncoding.DecodeTag(this); Length = BerEncoding.DecodeLength(this); if ((Length == BerDefinitions.IndefiniteLength) != (OuterLength == BerDefinitions.IndefiniteLength)) { ThrowError(12, "Outer and inner tag must use the same length form"); } } else { ThrowError(14, "Implicit tag or universal outer tag found"); } IsContainer = typeTag.IsContainer; Tag = Tag.ToPrimitive(); // clear container flag Type = typeTag.NumberAsType; if (Length == BerDefinitions.IndefiniteLength && IsContainer == false) { ThrowError(11, "Indefinite length form is only allowed on containers"); } if (IsContainer == false && Length > 0) { var value = new byte[Length]; for (int index = 0; index < Length; index++) { value[index] = ReadByte(); } Value = value; } return(true); }
bool ReadByte_Length(byte b) { if (_bytesExpected == 0) { if ((b & 0x80) != 0) { _bytesExpected = (b & 0x7F) + 1; } else { _bytesExpected = 1; } if (_bytesExpected > 5) { ThrowError(104, "Number of length octets out of bounds"); } } _bytesRead++; if (_bytesRead == _bytesExpected) { var input = new BerMemoryInput(_buffer); if (Type == 0) { OuterLength = BerEncoding.DecodeLength(input); if (OuterLength == 0) { ThrowError(102, "Zero outer length encountered"); } ResetState(DecodeState.Tag); } else { Length = BerEncoding.DecodeLength(input); var isEofOK = Length == 0; if (IsContainer) { ResetState(DecodeState.Tag); OnNewContainer(); PushContainer(); DisposeCurrentTlv(); return(isEofOK); } if (Length == 0) { OnValueReady(); } else { ResetState(DecodeState.Value); _buffer.Capacity = (int)Length; } return(isEofOK); } } return(false); }