public SortKey(string attributeName, string matchingRule, bool reverseOrder)
{
Utility.CheckOSVersion();
this.AttributeName = attributeName;
this.rule = matchingRule;
this.order = reverseOrder;
}
public DirectoryControl(string type, byte[] value, bool isCritical, bool serverSide)
{
this.directoryControlType = "";
this.directoryControlCriticality = true;
this.directoryControlServerSide = true;
Utility.CheckOSVersion();
this.directoryControlType = type;
if (type != null)
{
if (value != null)
{
this.directoryControlValue = new byte[(int)value.Length];
for (int i = 0; i < (int)value.Length; i++)
{
this.directoryControlValue[i] = value[i];
}
}
this.directoryControlCriticality = isCritical;
this.directoryControlServerSide = serverSide;
return;
}
else
{
throw new ArgumentNullException("type");
}
}
public DirectoryControl(string type, byte[] value, bool isCritical, bool serverSide)
{
Utility.CheckOSVersion();
_directoryControlType = type;
if (type == null)
throw new ArgumentNullException("type");
if (value != null)
{
directoryControlValue = new byte[value.Length];
for (int i = 0; i < value.Length; i++)
directoryControlValue[i] = value[i];
}
_directoryControlCriticality = isCritical;
_directoryControlServerSide = serverSide;
}
public DirectoryAttributeModificationCollection()
{
Utility.CheckOSVersion();
}
protected DirectoryIdentifier()
{
Utility.CheckOSVersion();
}
public DirectoryAttributeCollection()
{
Utility.CheckOSVersion();
}
public DsmlRequestDocument()
{
this.errProcessing = DsmlErrorProcessing.Exit;
Utility.CheckOSVersion();
this.dsmlRequests = new ArrayList();
}
public SortKey()
{
Utility.CheckOSVersion();
}
public DirectoryAttribute()
{
this.attributeName = "";
Utility.CheckOSVersion();
}
public static byte[] Encode(string format, object[] value)
{
int num;
Utility.CheckOSVersion();
if (format != null)
{
UTF8Encoding uTF8Encoding = new UTF8Encoding();
byte[] numArray = null;
if (value == null)
{
value = new object[0];
}
BerSafeHandle berSafeHandle = new BerSafeHandle();
int num1 = 0;
int num2 = 0;
int num3 = 0;
while (num3 < format.Length)
{
char chr = format[num3];
if (chr == '{' || chr == '}' || chr == '[' || chr == ']' || chr == 'n')
{
num2 = Wldap32.ber_printf_emptyarg(berSafeHandle, new string(chr, 1));
}
else
{
if (chr == 't' || chr == 'i' || chr == 'e')
{
if (num1 < (int)value.Length)
{
if (value[num1] is int)
{
num2 = Wldap32.ber_printf_int(berSafeHandle, new string(chr, 1), (int)value[num1]);
num1++;
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
else
{
if (chr != 'b')
{
if (chr != 's')
{
if (chr == 'o' || chr == 'X')
{
if (num1 < (int)value.Length)
{
if (value[num1] == null || value[num1] as byte[] != null)
{
byte[] numArray1 = (byte[])value[num1];
num2 = BerConverter.EncodingByteArrayHelper(berSafeHandle, numArray1, chr);
num1++;
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
else
{
if (chr != 'v')
{
if (chr != 'V')
{
throw new ArgumentException(Res.GetString("BerConverterUndefineChar"));
}
else
{
if (num1 < (int)value.Length)
{
if (value[num1] == null || value[num1] as byte[][] != null)
{
byte[][] numArray2 = (byte[][])value[num1];
num2 = BerConverter.EncodingMultiByteArrayHelper(berSafeHandle, numArray2, chr);
num1++;
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
}
else
{
if (num1 < (int)value.Length)
{
if (value[num1] == null || value[num1] as string[] != null)
{
string[] strArrays = (string[])value[num1];
byte[][] bytes = null;
if (strArrays != null)
{
bytes = new byte[(int)strArrays.Length][];
for (int i = 0; i < (int)strArrays.Length; i++)
{
string str = strArrays[i];
if (str != null)
{
bytes[i] = uTF8Encoding.GetBytes(str);
}
else
{
bytes[i] = null;
}
}
}
num2 = BerConverter.EncodingMultiByteArrayHelper(berSafeHandle, bytes, 'V');
num1++;
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
}
}
else
{
if (num1 < (int)value.Length)
{
if (value[num1] == null || value[num1] as string != null)
{
byte[] bytes1 = null;
if (value[num1] != null)
{
bytes1 = uTF8Encoding.GetBytes((string)value[num1]);
}
num2 = BerConverter.EncodingByteArrayHelper(berSafeHandle, bytes1, 'o');
num1++;
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
}
else
{
if (num1 < (int)value.Length)
{
if (value[num1] is bool)
{
BerSafeHandle berSafeHandle1 = berSafeHandle;
string str1 = new string(chr, 1);
if ((bool)value[num1])
{
num = 1;
}
else
{
num = 0;
}
num2 = Wldap32.ber_printf_int(berSafeHandle1, str1, num);
num1++;
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
else
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
}
}
}
if (num2 != -1)
{
num3++;
}
else
{
throw new BerConversionException();
}
}
berval _berval = new berval();
IntPtr intPtr = (IntPtr)0;
try
{
num2 = Wldap32.ber_flatten(berSafeHandle, ref intPtr);
if (num2 != -1)
{
if (intPtr != (IntPtr)0)
{
Marshal.PtrToStructure(intPtr, _berval);
}
if (_berval == null || _berval.bv_len == 0)
{
numArray = new byte[0];
}
else
{
numArray = new byte[_berval.bv_len];
Marshal.Copy(_berval.bv_val, numArray, 0, _berval.bv_len);
}
}
else
{
throw new BerConversionException();
}
}
finally
{
if (intPtr != (IntPtr)0)
{
Wldap32.ber_bvfree(intPtr);
}
}
return(numArray);
}
else
{
throw new ArgumentNullException("format");
}
}
public ReferralCallback()
{
Utility.CheckOSVersion();
}
public DirectoryException(string message) : base(message)
{
Utility.CheckOSVersion();
}
protected DirectoryConnection()
{
Utility.CheckOSVersion();
this.certificatesCollection = new X509CertificateCollection();
}
public static byte[] Encode(string format, params object[] value)
{
Utility.CheckOSVersion();
if (format == null)
{
throw new ArgumentNullException("format");
}
UTF8Encoding encoding = new UTF8Encoding();
byte[] destination = null;
if (value == null)
{
value = new object[0];
}
BerSafeHandle berElement = new BerSafeHandle();
int index = 0;
int num2 = 0;
for (int i = 0; i < format.Length; i++)
{
char c = format[i];
switch (c)
{
case '{':
case '}':
case '[':
case ']':
case 'n':
num2 = Wldap32.ber_printf_emptyarg(berElement, new string(c, 1));
break;
case 't':
case 'i':
case 'e':
if (index >= value.Length)
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
if (!(value[index] is int))
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
num2 = Wldap32.ber_printf_int(berElement, new string(c, 1), (int)value[index]);
index++;
break;
case 'b':
if (index >= value.Length)
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
if (!(value[index] is bool))
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
num2 = Wldap32.ber_printf_int(berElement, new string(c, 1), ((bool)value[index]) ? 1 : 0);
index++;
break;
case 's':
{
if (index >= value.Length)
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
if ((value[index] != null) && !(value[index] is string))
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
byte[] tempValue = null;
if (value[index] != null)
{
tempValue = encoding.GetBytes((string)value[index]);
}
num2 = EncodingByteArrayHelper(berElement, tempValue, 'o');
index++;
break;
}
case 'o':
case 'X':
{
if (index >= value.Length)
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
if ((value[index] != null) && !(value[index] is byte[]))
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
byte[] buffer3 = (byte[])value[index];
num2 = EncodingByteArrayHelper(berElement, buffer3, c);
index++;
break;
}
case 'v':
{
if (index >= value.Length)
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
if ((value[index] != null) && !(value[index] is string[]))
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
string[] strArray = (string[])value[index];
byte[][] bufferArray = null;
if (strArray != null)
{
bufferArray = new byte[strArray.Length][];
for (int j = 0; j < strArray.Length; j++)
{
string s = strArray[j];
if (s == null)
{
bufferArray[j] = null;
}
else
{
bufferArray[j] = encoding.GetBytes(s);
}
}
}
num2 = EncodingMultiByteArrayHelper(berElement, bufferArray, 'V');
index++;
break;
}
default:
{
if (c != 'V')
{
throw new ArgumentException(Res.GetString("BerConverterUndefineChar"));
}
if (index >= value.Length)
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
if ((value[index] != null) && !(value[index] is byte[][]))
{
throw new ArgumentException(Res.GetString("BerConverterNotMatch"));
}
byte[][] bufferArray2 = (byte[][])value[index];
num2 = EncodingMultiByteArrayHelper(berElement, bufferArray2, c);
index++;
break;
}
}
if (num2 == -1)
{
throw new BerConversionException();
}
}
berval structure = new berval();
IntPtr zero = IntPtr.Zero;
try
{
if (Wldap32.ber_flatten(berElement, ref zero) == -1)
{
throw new BerConversionException();
}
if (zero != IntPtr.Zero)
{
Marshal.PtrToStructure(zero, structure);
}
if ((structure == null) || (structure.bv_len == 0))
{
return(new byte[0]);
}
destination = new byte[structure.bv_len];
Marshal.Copy(structure.bv_val, destination, 0, structure.bv_len);
}
finally
{
if (zero != IntPtr.Zero)
{
Wldap32.ber_bvfree(zero);
}
}
return(destination);
}
internal static object[] TryDecode(string format, byte[] value, out bool decodeSucceeded)
{
Utility.CheckOSVersion();
if (format == null)
{
throw new ArgumentNullException("format");
}
UTF8Encoding encoding = new UTF8Encoding(false, true);
berval berval = new berval();
ArrayList list = new ArrayList();
BerSafeHandle berElement = null;
object[] objArray = null;
decodeSucceeded = false;
if (value == null)
{
berval.bv_len = 0;
berval.bv_val = IntPtr.Zero;
}
else
{
berval.bv_len = value.Length;
berval.bv_val = Marshal.AllocHGlobal(value.Length);
Marshal.Copy(value, 0, berval.bv_val, value.Length);
}
try
{
berElement = new BerSafeHandle(berval);
}
finally
{
if (berval.bv_val != IntPtr.Zero)
{
Marshal.FreeHGlobal(berval.bv_val);
}
}
int error = 0;
for (int i = 0; i < format.Length; i++)
{
char c = format[i];
switch (c)
{
case '{':
case '}':
case '[':
case ']':
case 'n':
case 'x':
error = Wldap32.ber_scanf(berElement, new string(c, 1));
if (error == 0)
{
}
break;
case 'i':
case 'e':
case 'b':
{
int num3 = 0;
error = Wldap32.ber_scanf_int(berElement, new string(c, 1), ref num3);
if (error == 0)
{
if (c == 'b')
{
bool flag = false;
if (num3 == 0)
{
flag = false;
}
else
{
flag = true;
}
list.Add(flag);
}
else
{
list.Add(num3);
}
}
break;
}
case 'a':
{
byte[] bytes = DecodingByteArrayHelper(berElement, 'O', ref error);
if (error == 0)
{
string str = null;
if (bytes != null)
{
str = encoding.GetString(bytes);
}
list.Add(str);
}
break;
}
case 'O':
{
byte[] buffer2 = DecodingByteArrayHelper(berElement, c, ref error);
if (error == 0)
{
list.Add(buffer2);
}
break;
}
case 'B':
{
IntPtr zero = IntPtr.Zero;
int length = 0;
error = Wldap32.ber_scanf_bitstring(berElement, "B", ref zero, ref length);
if (error == 0)
{
byte[] destination = null;
if (zero != IntPtr.Zero)
{
destination = new byte[length];
Marshal.Copy(zero, destination, 0, length);
}
list.Add(destination);
}
break;
}
case 'v':
{
byte[][] bufferArray = null;
string[] strArray = null;
bufferArray = DecodingMultiByteArrayHelper(berElement, 'V', ref error);
if (error == 0)
{
if (bufferArray != null)
{
strArray = new string[bufferArray.Length];
for (int k = 0; k < bufferArray.Length; k++)
{
if (bufferArray[k] == null)
{
strArray[k] = null;
}
else
{
strArray[k] = encoding.GetString(bufferArray[k]);
}
}
}
list.Add(strArray);
}
break;
}
default:
{
if (c != 'V')
{
throw new ArgumentException(Res.GetString("BerConverterUndefineChar"));
}
byte[][] bufferArray2 = null;
bufferArray2 = DecodingMultiByteArrayHelper(berElement, c, ref error);
if (error == 0)
{
list.Add(bufferArray2);
}
break;
}
}
if (error != 0)
{
return(objArray);
}
}
objArray = new object[list.Count];
for (int j = 0; j < list.Count; j++)
{
objArray[j] = list[j];
}
decodeSucceeded = true;
return(objArray);
}
internal static object[] TryDecode(string format, byte[] value, out bool decodeSucceeded)
{
Utility.CheckOSVersion();
if (format == null)
{
throw new ArgumentNullException("format");
}
Debug.WriteLine("Begin decoding\n");
UTF8Encoding utf8Encoder = new UTF8Encoding(false, true);
berval berValue = new berval();
ArrayList resultList = new ArrayList();
BerSafeHandle berElement = null;
object[] decodeResult = null;
decodeSucceeded = false;
if (value == null)
{
berValue.bv_len = 0;
berValue.bv_val = (IntPtr)0;
}
else
{
berValue.bv_len = value.Length;
berValue.bv_val = Marshal.AllocHGlobal(value.Length);
Marshal.Copy(value, 0, berValue.bv_val, value.Length);
}
try
{
berElement = new BerSafeHandle(berValue);
}
finally
{
if (berValue.bv_val != (IntPtr)0)
{
Marshal.FreeHGlobal(berValue.bv_val);
}
}
int error = 0;
for (int formatCount = 0; formatCount < format.Length; formatCount++)
{
char fmt = format[formatCount];
if (fmt == '{' || fmt == '}' || fmt == '[' || fmt == ']' || fmt == 'n' || fmt == 'x')
{
error = Wldap32.ber_scanf(berElement, new string(fmt, 1));
if (error != 0)
{
Debug.WriteLine("ber_scanf for {, }, [, ], n or x failed");
}
}
else if (fmt == 'i' || fmt == 'e' || fmt == 'b')
{
int result = 0;
error = Wldap32.ber_scanf_int(berElement, new string(fmt, 1), ref result);
if (error == 0)
{
if (fmt == 'b')
{
// should return a bool
bool boolResult = false;
if (result == 0)
{
boolResult = false;
}
else
{
boolResult = true;
}
resultList.Add(boolResult);
}
else
{
resultList.Add(result);
}
}
else
{
Debug.WriteLine("ber_scanf for format character 'i', 'e' or 'b' failed");
}
}
else if (fmt == 'a')
{
// return a string
byte[] byteArray = DecodingByteArrayHelper(berElement, 'O', ref error);
if (error == 0)
{
string s = null;
if (byteArray != null)
{
s = utf8Encoder.GetString(byteArray);
}
resultList.Add(s);
}
}
else if (fmt == 'O')
{
// return berval
byte[] byteArray = DecodingByteArrayHelper(berElement, fmt, ref error);
if (error == 0)
{
// add result to the list
resultList.Add(byteArray);
}
}
else if (fmt == 'B')
{
// return a bitstring and its length
IntPtr ptrResult = (IntPtr)0;
int length = 0;
error = Wldap32.ber_scanf_bitstring(berElement, "B", ref ptrResult, ref length);
if (error == 0)
{
byte[] byteArray = null;
if (ptrResult != (IntPtr)0)
{
byteArray = new byte[length];
Marshal.Copy(ptrResult, byteArray, 0, length);
}
resultList.Add(byteArray);
}
else
{
Debug.WriteLine("ber_scanf for format character 'B' failed");
}
// no need to free memory as wldap32 returns the original pointer instead of a duplicating memory pointer that
// needs to be freed
}
else if (fmt == 'v')
{
//null terminate strings
byte[][] byteArrayresult = null;
string[] stringArray = null;
byteArrayresult = DecodingMultiByteArrayHelper(berElement, 'V', ref error);
if (error == 0)
{
if (byteArrayresult != null)
{
stringArray = new string[byteArrayresult.Length];
for (int i = 0; i < byteArrayresult.Length; i++)
{
if (byteArrayresult[i] == null)
{
stringArray[i] = null;
}
else
{
stringArray[i] = utf8Encoder.GetString(byteArrayresult[i]);
}
}
}
resultList.Add(stringArray);
}
}
else if (fmt == 'V')
{
byte[][] result = null;
result = DecodingMultiByteArrayHelper(berElement, fmt, ref error);
if (error == 0)
{
resultList.Add(result);
}
}
else
{
Debug.WriteLine("Format string contains undefined character\n");
throw new ArgumentException(Res.GetString(Res.BerConverterUndefineChar));
}
if (error != 0)
{
// decode failed, just return
return(decodeResult);
}
}
decodeResult = new object[resultList.Count];
for (int count = 0; count < resultList.Count; count++)
{
decodeResult[count] = resultList[count];
}
decodeSucceeded = true;
return(decodeResult);
}
public static byte[] Encode(string format, params object[] value)
{
Utility.CheckOSVersion();
if (format == null)
{
throw new ArgumentNullException("format");
}
// no need to turn on invalid encoding detection as we just do string->byte[] conversion.
UTF8Encoding utf8Encoder = new UTF8Encoding();
byte[] encodingResult = null;
// value is allowed to be null in certain scenario, so if it is null, just set it to empty array.
if (value == null)
{
value = new object[0];
}
Debug.WriteLine("Begin encoding\n");
// allocate the berelement
BerSafeHandle berElement = new BerSafeHandle();
int valueCount = 0;
int error = 0;
for (int formatCount = 0; formatCount < format.Length; formatCount++)
{
char fmt = format[formatCount];
if (fmt == '{' || fmt == '}' || fmt == '[' || fmt == ']' || fmt == 'n')
{
// no argument needed
error = Wldap32.ber_printf_emptyarg(berElement, new string(fmt, 1));
}
else if (fmt == 't' || fmt == 'i' || fmt == 'e')
{
if (valueCount >= value.Length)
{
// we don't have enough argument for the format string
Debug.WriteLine("value argument is not valid, valueCount >= value.Length\n");
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
if (!(value[valueCount] is int))
{
// argument is wrong
Debug.WriteLine("type should be int\n");
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
// one int argument
error = Wldap32.ber_printf_int(berElement, new string(fmt, 1), (int)value[valueCount]);
// increase the value count
valueCount++;
}
else if (fmt == 'b')
{
if (valueCount >= value.Length)
{
// we don't have enough argument for the format string
Debug.WriteLine("value argument is not valid, valueCount >= value.Length\n");
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
if (!(value[valueCount] is bool))
{
// argument is wrong
Debug.WriteLine("type should be boolean\n");
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
// one int argument
error = Wldap32.ber_printf_int(berElement, new string(fmt, 1), (bool)value[valueCount] ? 1 : 0);
// increase the value count
valueCount++;
}
else if (fmt == 's')
{
if (valueCount >= value.Length)
{
// we don't have enough argument for the format string
Debug.WriteLine("value argument is not valid, valueCount >= value.Length\n");
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
if (value[valueCount] != null && !(value[valueCount] is string))
{
// argument is wrong
Debug.WriteLine("type should be string, but receiving value has type of ");
Debug.WriteLine(value[valueCount].GetType());
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
// one string argument
byte[] tempValue = null;
if (value[valueCount] != null)
{
tempValue = utf8Encoder.GetBytes((string)value[valueCount]);
}
error = EncodingByteArrayHelper(berElement, tempValue, 'o');
// increase the value count
valueCount++;
}
else if (fmt == 'o' || fmt == 'X')
{
// we need to have one arguments
if (valueCount >= value.Length)
{
// we don't have enough argument for the format string
Debug.WriteLine("value argument is not valid, valueCount >= value.Length\n");
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
if (value[valueCount] != null && !(value[valueCount] is byte[]))
{
// argument is wrong
Debug.WriteLine("type should be byte[], but receiving value has type of ");
Debug.WriteLine(value[valueCount].GetType());
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
byte[] tempValue = (byte[])value[valueCount];
error = EncodingByteArrayHelper(berElement, tempValue, fmt);
valueCount++;
}
else if (fmt == 'v')
{
// we need to have one arguments
if (valueCount >= value.Length)
{
// we don't have enough argument for the format string
Debug.WriteLine("value argument is not valid, valueCount >= value.Length\n");
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
if (value[valueCount] != null && !(value[valueCount] is string[]))
{
// argument is wrong
Debug.WriteLine("type should be string[], but receiving value has type of ");
Debug.WriteLine(value[valueCount].GetType());
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
string[] stringValues = (string[])value[valueCount];
byte[][] tempValues = null;
if (stringValues != null)
{
tempValues = new byte[stringValues.Length][];
for (int i = 0; i < stringValues.Length; i++)
{
string s = stringValues[i];
if (s == null)
{
tempValues[i] = null;
}
else
{
tempValues[i] = utf8Encoder.GetBytes(s);
}
}
}
error = EncodingMultiByteArrayHelper(berElement, tempValues, 'V');
valueCount++;
}
else if (fmt == 'V')
{
// we need to have one arguments
if (valueCount >= value.Length)
{
// we don't have enough argument for the format string
Debug.WriteLine("value argument is not valid, valueCount >= value.Length\n");
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
if (value[valueCount] != null && !(value[valueCount] is byte[][]))
{
// argument is wrong
Debug.WriteLine("type should be byte[][], but receiving value has type of ");
Debug.WriteLine(value[valueCount].GetType());
throw new ArgumentException(Res.GetString(Res.BerConverterNotMatch));
}
byte[][] tempValue = (byte[][])value[valueCount];
error = EncodingMultiByteArrayHelper(berElement, tempValue, fmt);
valueCount++;
}
else
{
Debug.WriteLine("Format string contains undefined character: ");
Debug.WriteLine(new string(fmt, 1));
throw new ArgumentException(Res.GetString(Res.BerConverterUndefineChar));
}
// process the return value
if (error == -1)
{
Debug.WriteLine("ber_printf failed\n");
throw new BerConversionException();
}
}
// get the binary value back
berval binaryValue = new berval();
IntPtr flattenptr = (IntPtr)0;
try
{
// can't use SafeBerval here as CLR creates a SafeBerval which points to a different memory location, but when doing memory
// deallocation, wldap has special check. So have to use IntPtr directly here.
error = Wldap32.ber_flatten(berElement, ref flattenptr);
if (error == -1)
{
Debug.WriteLine("ber_flatten failed\n");
throw new BerConversionException();
}
if (flattenptr != (IntPtr)0)
{
Marshal.PtrToStructure(flattenptr, binaryValue);
}
if (binaryValue == null || binaryValue.bv_len == 0)
{
encodingResult = new byte[0];
}
else
{
encodingResult = new byte[binaryValue.bv_len];
Marshal.Copy(binaryValue.bv_val, encodingResult, 0, binaryValue.bv_len);
}
}
finally
{
if (flattenptr != (IntPtr)0)
{
Wldap32.ber_bvfree(flattenptr);
}
}
return(encodingResult);
}
internal DirectoryRequest()
{
Utility.CheckOSVersion();
this.directoryControlCollection = new DirectoryControlCollection();
}
public DirectoryControlCollection()
{
Utility.CheckOSVersion();
}
public DirectoryException() : base()
{
Utility.CheckOSVersion();
}
protected DirectoryConnection()
{
this.connectionTimeOut = new TimeSpan(0, 0, 30);
Utility.CheckOSVersion();
this.certificatesCollection = new X509CertificateCollection();
}
public DsmlRequestDocument()
{
Utility.CheckOSVersion();
this.dsmlRequests = new ArrayList();
}
internal static object[] TryDecode(string format, byte[] value, out bool decodeSucceeded)
{
Utility.CheckOSVersion();
if (format != null)
{
UTF8Encoding uTF8Encoding = new UTF8Encoding(false, true);
berval _berval = new berval();
ArrayList arrayLists = new ArrayList();
BerSafeHandle berSafeHandle = null;
object[] item = null;
decodeSucceeded = false;
if (value != null)
{
_berval.bv_len = (int)value.Length;
_berval.bv_val = Marshal.AllocHGlobal((int)value.Length);
Marshal.Copy(value, 0, _berval.bv_val, (int)value.Length);
}
else
{
_berval.bv_len = 0;
_berval.bv_val = (IntPtr)0;
}
try
{
berSafeHandle = new BerSafeHandle(_berval);
}
finally
{
if (_berval.bv_val != (IntPtr)0)
{
Marshal.FreeHGlobal(_berval.bv_val);
}
}
int num = 0;
int num1 = 0;
while (num1 < format.Length)
{
char chr = format[num1];
if (chr == '{' || chr == '}' || chr == '[' || chr == ']' || chr == 'n' || chr == 'x')
{
num = Wldap32.ber_scanf(berSafeHandle, new string(chr, 1));
if (num != 0)
{
}
}
else
{
if (chr == 'i' || chr == 'e' || chr == 'b')
{
int num2 = 0;
num = Wldap32.ber_scanf_int(berSafeHandle, new string(chr, 1), ref num2);
if (num == 0)
{
if (chr != 'b')
{
arrayLists.Add(num2);
}
else
{
bool flag = false;
if (num2 != 0)
{
flag = true;
}
else
{
flag = false;
}
arrayLists.Add(flag);
}
}
}
else
{
if (chr != 'a')
{
if (chr != 'O')
{
if (chr != 'B')
{
if (chr != 'v')
{
if (chr != 'V')
{
throw new ArgumentException(Res.GetString("BerConverterUndefineChar"));
}
else
{
byte[][] numArray = BerConverter.DecodingMultiByteArrayHelper(berSafeHandle, chr, ref num);
if (num == 0)
{
arrayLists.Add(numArray);
}
}
}
else
{
string[] str = null;
byte[][] numArray1 = BerConverter.DecodingMultiByteArrayHelper(berSafeHandle, 'V', ref num);
if (num == 0)
{
if (numArray1 != null)
{
str = new string[(int)numArray1.Length];
for (int i = 0; i < (int)numArray1.Length; i++)
{
if (numArray1[i] != null)
{
str[i] = uTF8Encoding.GetString(numArray1[i]);
}
else
{
str[i] = null;
}
}
}
arrayLists.Add(str);
}
}
}
else
{
IntPtr intPtr = (IntPtr)0;
int num3 = 0;
num = Wldap32.ber_scanf_bitstring(berSafeHandle, "B", ref intPtr, ref num3);
if (num == 0)
{
byte[] numArray2 = null;
if (intPtr != (IntPtr)0)
{
numArray2 = new byte[num3];
Marshal.Copy(intPtr, numArray2, 0, num3);
}
arrayLists.Add(numArray2);
}
}
}
else
{
byte[] numArray3 = BerConverter.DecodingByteArrayHelper(berSafeHandle, chr, ref num);
if (num == 0)
{
arrayLists.Add(numArray3);
}
}
}
else
{
byte[] numArray4 = BerConverter.DecodingByteArrayHelper(berSafeHandle, 'O', ref num);
if (num == 0)
{
string str1 = null;
if (numArray4 != null)
{
str1 = uTF8Encoding.GetString(numArray4);
}
arrayLists.Add(str1);
}
}
}
}
if (num == 0)
{
num1++;
}
else
{
return(item);
}
}
item = new object[arrayLists.Count];
for (int j = 0; j < arrayLists.Count; j++)
{
item[j] = arrayLists[j];
}
decodeSucceeded = true;
return(item);
}
else
{
throw new ArgumentNullException("format");
}
}