internal void RetrieveMessages()
{
var decoder = new LBERDecoder();
while (!_cts.IsCancellationRequested)
{
try
{
var asn1Id = new Asn1Identifier(_conn.ActiveStream);
if (asn1Id.Tag != Asn1Sequence.Tag)
{
continue; // loop looking for an RfcLdapMessage identifier
}
// Turn the message into an RfcMessage class
var asn1Len = new Asn1Length(_conn.ActiveStream);
Messages.Add(new RfcLdapMessage(decoder, _conn.ActiveStream, asn1Len.Length));
}
catch (System.IO.IOException)
{
// ignore
}
}
// ReSharper disable once FunctionNeverReturns
}
public RfcExtendedResponse(Asn1Decoder dec, System.IO.Stream in_Renamed, int len) : base(dec, in_Renamed, len)
{
// decode optional tagged elements
if (size() > 3)
{
for (int i = 3; i < size(); i++)
{
Asn1Tagged obj = (Asn1Tagged)get_Renamed(i);
Asn1Identifier id = obj.getIdentifier();
switch (id.Tag)
{
case RfcLdapResult.REFERRAL:
sbyte[] content = ((Asn1OctetString)obj.taggedValue()).byteValue();
System.IO.MemoryStream bais = new System.IO.MemoryStream(SupportClass.ToByteArray(content));
set_Renamed(i, new RfcReferral(dec, bais, content.Length));
referralIndex = i;
break;
case RESPONSE_NAME:
set_Renamed(i, new RfcLdapOID(((Asn1OctetString)obj.taggedValue()).byteValue()));
responseNameIndex = i;
break;
case RESPONSE:
set_Renamed(i, obj.taggedValue());
responseIndex = i;
break;
}
}
}
}
public RfcBindResponse(Asn1Decoder dec, System.IO.Stream in_Renamed, int len) : base(dec, in_Renamed, len)
{
// Decode optional referral from Asn1OctetString to Referral.
if (size() > 3)
{
Asn1Tagged obj = (Asn1Tagged)get_Renamed(3);
Asn1Identifier id = obj.getIdentifier();
if (id.Tag == RfcLdapResult.REFERRAL)
{
sbyte[] content = ((Asn1OctetString)obj.taggedValue()).byteValue();
System.IO.MemoryStream bais = new System.IO.MemoryStream(SupportClass.ToByteArray(content));
set_Renamed(3, new RfcReferral(dec, bais, content.Length));
}
}
}
/// <summary>
/// Encode an Asn1Identifier directly into the specified outputstream.
/// </summary>
/// <param name="id">The Asn1Identifier object to encode</param>
/// <param name="stream">The stream.</param>
public void Encode(Asn1Identifier id, Stream stream)
{
var c = (int)id.Asn1Class;
var t = id.Tag;
var ccf = (sbyte)((c << 6) | (id.Constructed ? 0x20 : 0));
if (t < 30)
{
stream.WriteByte((byte)(ccf | t));
}
else
{
stream.WriteByte((byte)(ccf | 0x1F));
EncodeTagInteger(t, stream);
}
}
/// <summary>
/// Decode an LBER encoded value into an Asn1Object from an InputStream.
/// This method also returns the total length of this encoded
/// Asn1Object (length of type + length of length + length of content)
/// in the parameter len. This information is helpful when decoding
/// structured types.
/// </summary>
/// <param name="stream">The stream.</param>
/// <param name="len">The length.</param>
/// <returns>
/// Decoded Asn1Obect.
/// </returns>
/// <exception cref="EndOfStreamException">Unknown tag.</exception>
public static Asn1Object Decode(Stream stream, int[] len)
{
var asn1Id = new Asn1Identifier(stream);
var asn1Len = new Asn1Length(stream);
var length = asn1Len.Length;
len[0] = asn1Id.EncodedLength + asn1Len.EncodedLength + length;
if (asn1Id.Universal == false)
{
return(new Asn1Tagged(stream, length, (Asn1Identifier)asn1Id.Clone()));
}
switch (asn1Id.Tag)
{
case Asn1Sequence.Tag:
return(new Asn1Sequence(stream, length));
case Asn1Set.Tag:
return(new Asn1Set(stream, length));
case Asn1Boolean.Tag:
return(new Asn1Boolean(stream, length));
case Asn1Integer.Tag:
return(new Asn1Integer(stream, length));
case Asn1OctetString.Tag:
return(new Asn1OctetString(stream, length));
case Asn1Enumerated.Tag:
return(new Asn1Enumerated(stream, length));
case Asn1Null.Tag:
return(new Asn1Null()); // has no content to decode.
default:
throw new EndOfStreamException("Unknown tag");
}
}
public RfcIntermediateResponse(Asn1Decoder dec, Stream in_Renamed, int len)
: base(dec, in_Renamed, len)
// throws IOException
{
// super(dec, in, len);
int i = 0;
m_responseNameIndex = m_responseValueIndex = 0;
// decode optional tagged elements. The parent class constructor will
// have decoded these elements as ASN1Tagged objects with the value
// stored as an ASN1OctectString object.
if (size() >= 3) //the incorrectly encoded case, LDAPResult contains
{
i = 3; //at least 3 components
}
else
{
i = 0; //correctly encoded case, can have zero components
}
for (; i < size(); i++)
{
Asn1Tagged obj = (Asn1Tagged)get_Renamed(i);
Asn1Identifier id = obj.getIdentifier();
switch (id.Tag)
{
case TAG_RESPONSE_NAME:
set_Renamed(i, new RfcLdapOID(
((Asn1OctetString)obj.taggedValue()).byteValue()));
m_responseNameIndex = i;
break;
case TAG_RESPONSE:
set_Renamed(i, obj.taggedValue());
m_responseValueIndex = i;
break;
}
}
}
public RfcLdapMessage(Asn1Decoder dec, Stream in_Renamed, int len) : base(dec, in_Renamed, len)
{
sbyte[] content;
MemoryStream bais;
// Decode implicitly tagged protocol operation from an Asn1Tagged type
// to its appropriate application type.
Asn1Tagged protocolOp = (Asn1Tagged)get_Renamed(1);
Asn1Identifier protocolOpId = protocolOp.getIdentifier();
content = ((Asn1OctetString)protocolOp.taggedValue()).byteValue();
bais = new MemoryStream(SupportClass.ToByteArray(content));
switch (protocolOpId.Tag)
{
case LdapMessage.SEARCH_RESPONSE:
set_Renamed(1, new RfcSearchResultEntry(dec, bais, content.Length));
break;
case LdapMessage.SEARCH_RESULT:
set_Renamed(1, new RfcSearchResultDone(dec, bais, content.Length));
break;
case LdapMessage.SEARCH_RESULT_REFERENCE:
set_Renamed(1, new RfcSearchResultReference(dec, bais, content.Length));
break;
case LdapMessage.ADD_RESPONSE:
set_Renamed(1, new RfcAddResponse(dec, bais, content.Length));
break;
case LdapMessage.BIND_RESPONSE:
set_Renamed(1, new RfcBindResponse(dec, bais, content.Length));
break;
case LdapMessage.COMPARE_RESPONSE:
set_Renamed(1, new RfcCompareResponse(dec, bais, content.Length));
break;
case LdapMessage.DEL_RESPONSE:
set_Renamed(1, new RfcDelResponse(dec, bais, content.Length));
break;
case LdapMessage.EXTENDED_RESPONSE:
set_Renamed(1, new RfcExtendedResponse(dec, bais, content.Length));
break;
case LdapMessage.INTERMEDIATE_RESPONSE:
set_Renamed(1, new RfcIntermediateResponse(dec, bais, content.Length));
break;
case LdapMessage.MODIFY_RESPONSE:
set_Renamed(1, new RfcModifyResponse(dec, bais, content.Length));
break;
case LdapMessage.MODIFY_RDN_RESPONSE:
set_Renamed(1, new RfcModifyDNResponse(dec, bais, content.Length));
break;
default:
throw new Exception("RfcLdapMessage: Invalid tag: " + protocolOpId.Tag);
}
// decode optional implicitly tagged controls from Asn1Tagged type to
// to RFC 2251 types.
if (size() > 2)
{
Asn1Tagged controls = (Asn1Tagged)get_Renamed(2);
// Asn1Identifier controlsId = protocolOp.getIdentifier();
// we could check to make sure we have controls here....
content = ((Asn1OctetString)controls.taggedValue()).byteValue();
bais = new MemoryStream(SupportClass.ToByteArray(content));
set_Renamed(2, new RfcControls(dec, bais, content.Length));
}
}
public LBERDecoder()
{
asn1ID = new Asn1Identifier();
asn1Len = new Asn1Length();
}
internal Asn1Numeric(Asn1Identifier id, long valueRenamed)
: base(id)
{
_content = valueRenamed;
}
