public override int encodeBitString(Object obj, System.IO.Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
BitString str = (BitString)obj;
CoderUtils.checkConstraints(str.getLengthInBits(), elementInfo);
byte[] buffer = str.Value;
string s = "";
if (elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo())
{
s = elementInfo.PreparedASN1ElementInfo.Name;
}
if (s == "")
{
s = "unnamedBitString" + unknown.ToString("D3");
unknown++;
}
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for (int i = 0; i < buffer.Length; i++)
{
for (int j = 0; j < 8; j++)
{
sb.Append((buffer[i] >> j & 1).ToString());
}
if (i < buffer.Length - 1)
{
sb.Append(',');
}
}
resultSize += printString(stream, "<" + s + " type=\"BitString\">" + sb.ToString() + "</" + s + ">\r\n");
return(resultSize);
}
public override int encodeAny(object obj, System.IO.Stream stream, ElementInfo elementInfo)
{
int resultSize = 0, sizeOfString = 0;
byte[] buffer = (byte[])obj;
CoderUtils.checkConstraints(sizeOfString, elementInfo);
System.Text.StringBuilder sb = new System.Text.StringBuilder();
for (int i = 0; i < buffer.Length; i++)
{
sb.Append(buffer[i]);
sb.Append(',');
}
string s = "";
if (elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo())
{
s = elementInfo.PreparedASN1ElementInfo.Name;
}
if (s == "")
{
s = "unnamedAny" + unknown.ToString("D3");
unknown++;
}
resultSize += printString(stream, "<" + s + " type=\"Any\">" + sb.ToString() + "</" + s + ">\r\n");
return(resultSize);
}
public override DecodedObject <object> decodeSequenceOf(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!CoderUtils.isSequenceSetOf(elementInfo))
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence, elementInfo))
{
return(null);
}
}
else
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set, elementInfo))
{
return(null);
}
}
Type paramType = (System.Type)objectClass.GetGenericArguments()[0];
Type collectionType = typeof(List <>);
Type genCollectionType = collectionType.MakeGenericType(paramType);
Object param = Activator.CreateInstance(genCollectionType);
DecodedObject <int> len = decodeLength(stream);
if (len.Value != 0)
{
int lenOfItems = 0;
int itemsCnt = 0;
do
{
ElementInfo info = new ElementInfo();
info.ParentAnnotatedClass = elementInfo.AnnotatedClass;
info.AnnotatedClass = paramType;
if (elementInfo.hasPreparedInfo())
{
ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata;
info.PreparedInfo = (seqOfMeta.getItemClassMetadata());
}
DecodedObject <object> itemTag = decodeTag(stream);
DecodedObject <object> item = decodeClassType(itemTag, paramType, info, stream);
MethodInfo method = param.GetType().GetMethod("Add");
if (item != null)
{
lenOfItems += item.Size + itemTag.Size;
method.Invoke(param, new object[] { item.Value });
itemsCnt++;
}
}while (lenOfItems < len.Value);
CoderUtils.checkConstraints(itemsCnt, elementInfo);
}
return(new DecodedObject <object>(param, len.Value + len.Size));
}
public override int encodeAny(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0, sizeOfString = 0;
byte[] buffer = (byte[])obj;
sizeOfString = buffer.Length;
CoderUtils.checkConstraints(sizeOfString, elementInfo);
stream.Write(buffer, 0, buffer.Length);
resultSize += sizeOfString;
return(resultSize);
}
public override DecodedObject <object> decodeOctetString(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.OctetString, elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
CoderUtils.checkConstraints(len.Value, elementInfo);
byte[] byteBuf = new byte[len.Value];
stream.Read(byteBuf, 0, byteBuf.Length);
return(new DecodedObject <object>(byteBuf, len.Value + len.Size));
}
public override DecodedObject <object> decodeBitString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Bitstring, elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
int trailBitCnt = stream.ReadByte();
CoderUtils.checkConstraints(len.Value * 8 - trailBitCnt, elementInfo);
byte[] byteBuf = new byte[len.Value - 1];
stream.Read(byteBuf, 0, byteBuf.Length);
return(new DecodedObject <object>(new BitString(byteBuf, trailBitCnt), len.Value + len.Size));
}
protected int encodeLength(int val, ElementInfo elementInfo, System.IO.Stream stream)
{
CoderUtils.checkConstraints(val, elementInfo);
int resultSize = 0;
BitArrayOutputStream bitStream = (BitArrayOutputStream)stream;
if (elementInfo.hasPreparedInfo())
{
if (elementInfo.PreparedInfo.hasConstraint())
{
IASN1ConstraintMetadata constraint = elementInfo.PreparedInfo.Constraint;
if (constraint is ASN1ValueRangeConstraintMetadata)
{
resultSize += encodeConstraintLengthDeterminant(
val,
(int)((ASN1ValueRangeConstraintMetadata)constraint).Min,
(int)((ASN1ValueRangeConstraintMetadata)constraint).Max,
bitStream
);
}
else
if (constraint is ASN1SizeConstraintMetadata)
{
}
}
else
{
resultSize += encodeLengthDeterminant(val, bitStream);
}
}
else
{
if (elementInfo.isAttributePresent <ASN1ValueRangeConstraint>())
{
ASN1ValueRangeConstraint constraint = elementInfo.getAttribute <ASN1ValueRangeConstraint>();
resultSize += encodeConstraintLengthDeterminant(val, (int)constraint.Min, (int)constraint.Max, bitStream);
}
else
if (elementInfo.isAttributePresent <ASN1SizeConstraint>())
{
ASN1SizeConstraint constraint = elementInfo.getAttribute <ASN1SizeConstraint>();
}
else
{
resultSize += encodeLengthDeterminant(val, bitStream);
}
}
return(resultSize);
}
public override int encodeString(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0, sizeOfString = 0;
byte[] buffer = CoderUtils.ASN1StringToBuffer(obj, elementInfo);
sizeOfString = buffer.Length;
CoderUtils.checkConstraints(sizeOfString, elementInfo);
stream.Write(buffer, 0, buffer.Length);
resultSize += sizeOfString;
resultSize += encodeLength(sizeOfString, stream);
resultSize += encodeTag(BERCoderUtils.getTagValueForElement(elementInfo, TagClasses.Universal, ElementType.Primitive, CoderUtils.getStringTagForElement(elementInfo)), stream);
return(resultSize);
}
public override DecodedObject <object> decodeString(DecodedObject <object> decodedTag, Type objectClass, ElementInfo elementInfo, Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, CoderUtils.getStringTagForElement(elementInfo), elementInfo))
{
return(null);
}
DecodedObject <int> len = decodeLength(stream);
CoderUtils.checkConstraints(len.Value, elementInfo);
byte[] byteBuf = new byte[len.Value];
stream.Read(byteBuf, 0, byteBuf.Length);
string result = CoderUtils.bufferToASN1String(byteBuf, elementInfo);
return(new DecodedObject <object>(result, len.Value + len.Size));
}
protected virtual int decodeLength(ElementInfo elementInfo, System.IO.Stream stream)
{
int result = 0;
BitArrayInputStream bitStream = (BitArrayInputStream)stream;
if (elementInfo.hasPreparedInfo())
{
if (elementInfo.PreparedInfo.hasConstraint())
{
IASN1ConstraintMetadata constraint = elementInfo.PreparedInfo.Constraint;
if (constraint is ASN1ValueRangeConstraintMetadata)
{
result = decodeConstraintLengthDeterminant(
(int)((ASN1ValueRangeConstraintMetadata)constraint).Min,
(int)((ASN1ValueRangeConstraintMetadata)constraint).Max,
bitStream
);
}
else
if (constraint is ASN1SizeConstraintMetadata)
{
result = (int)((ASN1SizeConstraintMetadata)constraint).Max;
}
}
else
{
result = decodeLengthDeterminant(bitStream);
}
}
else
if (elementInfo.isAttributePresent <ASN1ValueRangeConstraint>())
{
ASN1ValueRangeConstraint constraint = elementInfo.getAttribute <ASN1ValueRangeConstraint>();
result = decodeConstraintLengthDeterminant((int)constraint.Min, (int)constraint.Max, bitStream);
}
else
if (elementInfo.isAttributePresent <ASN1SizeConstraint>())
{
ASN1SizeConstraint constraint = elementInfo.getAttribute <ASN1SizeConstraint>();
result = (int)constraint.Max;
}
else
{
result = decodeLengthDeterminant(bitStream);
}
CoderUtils.checkConstraints(result, elementInfo);
return(result);
}
public override DecodedObject <object> decodeInteger(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
if (!checkTagForObject(decodedTag, TagClasses.Universal, ElementType.Primitive, UniversalTags.Integer, elementInfo))
{
return(null);
}
if (objectClass.Equals(typeof(int)))
{
DecodedObject <object> result = decodeIntegerValue(stream);
CoderUtils.checkConstraints((int)result.Value, elementInfo);
return(result);
}
else
{
DecodedObject <object> result = decodeLongValue(stream);
CoderUtils.checkConstraints((long)result.Value, elementInfo);
return(result);
}
}
public override int encodeBitString(Object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0, sizeOfString = 0;
BitString str = (BitString)obj;
CoderUtils.checkConstraints(str.getLengthInBits(), elementInfo);
byte[] buffer = str.Value;
stream.Write(buffer, 0, buffer.Length);
stream.WriteByte((byte)str.getTrailBitsCnt());
sizeOfString = buffer.Length + 1;
resultSize += sizeOfString;
resultSize += encodeLength(sizeOfString, stream);
resultSize += encodeTag(
BERCoderUtils.getTagValueForElement(elementInfo, TagClasses.Universal, ElementType.Primitive, UniversalTags.Bitstring),
stream
);
return(resultSize);
}
public override int encodeSequenceOf(object obj, System.IO.Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
string s = "";
if (elementInfo.hasPreparedInfo() && elementInfo.hasPreparedASN1ElementInfo())
{
s = elementInfo.PreparedASN1ElementInfo.Name;
}
if (s == "")
{
s = "unnamedSequenceOf" + unknown.ToString("D3");
unknown++;
}
resultSize += printString(stream, "<" + s + " type=\"SequenceOf\">\r\n");
indent += indOfs;
System.Collections.IList collection = (System.Collections.IList)obj;
CoderUtils.checkConstraints(collection.Count, elementInfo);
int sizeOfCollection = 0;
//for (int i = 0; i < collection.Count; i++)
for (int i = collection.Count - 1; i >= 0; i--)
{
object item = collection[collection.Count - 1 - i];
ElementInfo info = new ElementInfo();
info.AnnotatedClass = item.GetType();
info.ParentAnnotatedClass = elementInfo.AnnotatedClass;
if (elementInfo.hasPreparedInfo() && elementInfo.PreparedInfo.TypeMetadata != null)
{
ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata;
info.PreparedInfo = (seqOfMeta.getItemClassMetadata());
}
sizeOfCollection += encodeClassType(item, stream, info);
}
resultSize += sizeOfCollection;
indent -= indOfs;
resultSize += printString(stream, "</" + s + ">\r\n");
return(resultSize);
}
public override DecodedObject <object> decodeAny(DecodedObject <object> decodedTag, System.Type objectClass, ElementInfo elementInfo, System.IO.Stream stream)
{
int bufSize = elementInfo.MaxAvailableLen;
if (bufSize == 0)
{
return(null);
}
System.IO.MemoryStream anyStream = new System.IO.MemoryStream(1024);
/*int tagValue = (int)decodedTag.Value;
* for (int i = 0; i < decodedTag.Size; i++)
* {
* anyStream.WriteByte((byte)tagValue);
* tagValue = tagValue >> 8;
* }*/
if (bufSize < 0)
{
bufSize = 1024;
}
int len = 0;
if (bufSize > 0)
{
byte[] buffer = new byte[bufSize];
int readed = stream.Read(buffer, 0, buffer.Length);
while (readed > 0)
{
anyStream.Write(buffer, 0, readed);
len += readed;
if (elementInfo.MaxAvailableLen > 0)
{
break;
}
readed = stream.Read(buffer, 0, buffer.Length);
}
}
CoderUtils.checkConstraints(len, elementInfo);
return(new DecodedObject <object>(anyStream.ToArray(), len));
}
public override int encodeInteger(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
int szOfInt = 0;
if (obj.GetType().Equals(typeof(int)))
{
int val = (int)obj;
CoderUtils.checkConstraints(val, elementInfo);
szOfInt = encodeIntegerValue(val, stream);
}
else
{
long val = (long)obj;
CoderUtils.checkConstraints(val, elementInfo);
szOfInt = encodeIntegerValue(val, stream);
}
resultSize += szOfInt;
resultSize += encodeLength(szOfInt, stream);
resultSize += encodeTag(BERCoderUtils.getTagValueForElement(elementInfo, TagClasses.Universal, ElementType.Primitive, UniversalTags.Integer), stream);
return(resultSize);
}
public override int encodeSequenceOf(object obj, Stream stream, ElementInfo elementInfo)
{
int resultSize = 0;
IList collection = (IList)obj;
CoderUtils.checkConstraints(collection.Count, elementInfo);
int sizeOfCollection = 0;
for (int i = 0; i < collection.Count; i++)
{
object item = collection[collection.Count - 1 - i];
ElementInfo info = new ElementInfo();
info.AnnotatedClass = item.GetType();
info.ParentAnnotatedClass = elementInfo.AnnotatedClass;
if (elementInfo.hasPreparedInfo())
{
ASN1SequenceOfMetadata seqOfMeta = (ASN1SequenceOfMetadata)elementInfo.PreparedInfo.TypeMetadata;
info.PreparedInfo = (seqOfMeta.getItemClassMetadata());
}
sizeOfCollection += encodeClassType(item, stream, info);
}
resultSize += sizeOfCollection;
resultSize += encodeLength(sizeOfCollection, stream);
if (!CoderUtils.isSequenceSetOf(elementInfo))
{
resultSize += encodeTag(BERCoderUtils.getTagValueForElement(elementInfo, TagClasses.Universal, ElementType.Constructed, UniversalTags.Sequence), stream);
}
else
{
resultSize += encodeTag(BERCoderUtils.getTagValueForElement(elementInfo, TagClasses.Universal, ElementType.Constructed, UniversalTags.Set), stream);
}
return(resultSize);
}
