public static void CheckAndSetLdapError(int error)
{
string str;
if (error == 0)
{
return;
}
else
{
if (!Utility.IsResultCode((ResultCode)error))
{
if (!Utility.IsLdapError((LdapError)error))
{
throw new LdapException(error);
}
else
{
str = LdapErrorMappings.MapResultCode(error);
throw new LdapException(error, str);
}
}
else
{
str = OperationErrorMappings.MapResultCode(error);
throw new DirectoryOperationException(null, str);
}
}
}
public override DirectoryResponse SendRequest(DirectoryRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
DsmlRequestDocument document = new DsmlRequestDocument();
document.Add(request);
DsmlResponseDocument document2 = this.SendRequestHelper(document.ToXml().InnerXml);
if (document2.Count == 0)
{
throw new DsmlInvalidDocumentException(System.DirectoryServices.Protocols.Res.GetString("MissingResponse"));
}
DirectoryResponse response = document2[0];
if (response is DsmlErrorResponse)
{
ErrorResponseException exception = new ErrorResponseException((DsmlErrorResponse)response);
throw exception;
}
ResultCode resultCode = response.ResultCode;
if (((resultCode != ResultCode.Success) && (resultCode != ResultCode.CompareFalse)) && (((resultCode != ResultCode.CompareTrue) && (resultCode != ResultCode.Referral)) && (resultCode != ResultCode.ReferralV2)))
{
throw new DirectoryOperationException(response, OperationErrorMappings.MapResultCode((int)resultCode));
}
return(response);
}
public static void CheckAndSetLdapError(int error)
{
if (error != (int)ResultCode.Success)
{
if (Utility.IsResultCode((ResultCode)error))
{
string errorMessage = OperationErrorMappings.MapResultCode(error);
throw new DirectoryOperationException(null, errorMessage);
}
else if (Utility.IsLdapError((LdapError)error))
{
string errorMessage = LdapErrorMappings.MapResultCode(error);
throw new LdapException(error, errorMessage);
}
else
{
throw new LdapException(error);
}
}
}
public override DirectoryResponse SendRequest(DirectoryRequest request)
{
if (request == null)
{
throw new ArgumentNullException("request");
}
DsmlRequestDocument doc = new DsmlRequestDocument();
doc.Add(request);
DsmlResponseDocument response = SendRequestHelper(doc.ToXml().InnerXml);
if (response.Count == 0)
{
throw new DsmlInvalidDocumentException(Res.GetString(Res.MissingResponse));
}
DirectoryResponse result = response[0];
if (result is DsmlErrorResponse)
{
// need to throw ErrorResponseException
ErrorResponseException e = new ErrorResponseException((DsmlErrorResponse)result);
throw e;
}
else
{
ResultCode error = result.ResultCode;
if (error == ResultCode.Success || error == ResultCode.CompareFalse || error == ResultCode.CompareTrue || error == ResultCode.Referral || error == ResultCode.ReferralV2)
{
return(result);
}
else
{
throw new DirectoryOperationException(result, OperationErrorMappings.MapResultCode((int)error));
}
}
}
public override DirectoryResponse SendRequest(DirectoryRequest request)
{
if (request != null)
{
DsmlRequestDocument dsmlRequestDocuments = new DsmlRequestDocument();
dsmlRequestDocuments.Add(request);
DsmlResponseDocument dsmlResponseDocuments = this.SendRequestHelper(dsmlRequestDocuments.ToXml().InnerXml);
if (dsmlResponseDocuments.Count != 0)
{
DirectoryResponse item = dsmlResponseDocuments[0];
if (item as DsmlErrorResponse == null)
{
ResultCode resultCode = item.ResultCode;
if (resultCode == ResultCode.Success || resultCode == ResultCode.CompareFalse || resultCode == ResultCode.CompareTrue || resultCode == ResultCode.Referral || resultCode == ResultCode.ReferralV2)
{
return(item);
}
else
{
throw new DirectoryOperationException(item, OperationErrorMappings.MapResultCode((int)resultCode));
}
}
else
{
ErrorResponseException errorResponseException = new ErrorResponseException((DsmlErrorResponse)item);
throw errorResponseException;
}
}
else
{
throw new DsmlInvalidDocumentException(Res.GetString("MissingResponse"));
}
}
else
{
throw new ArgumentNullException("request");
}
}
public unsafe void StartTransportLayerSecurity(DirectoryControlCollection controls)
{
IntPtr zero = IntPtr.Zero;
LdapControl[] controlArray = null;
IntPtr clientControls = IntPtr.Zero;
LdapControl[] controlArray2 = null;
IntPtr message = IntPtr.Zero;
IntPtr referral = IntPtr.Zero;
int serverReturnValue = 0;
Uri[] uriArray = null;
if (Utility.IsWin2kOS)
{
throw new PlatformNotSupportedException(Res.GetString("TLSNotSupported"));
}
if (this.connection.disposed)
{
throw new ObjectDisposedException(base.GetType().Name);
}
try
{
IntPtr ptr = IntPtr.Zero;
IntPtr ptr6 = IntPtr.Zero;
controlArray = this.connection.BuildControlArray(controls, true);
int cb = Marshal.SizeOf(typeof(LdapControl));
if (controlArray != null)
{
zero = Marshal.AllocHGlobal((int)(Marshal.SizeOf(typeof(IntPtr)) * (controlArray.Length + 1)));
for (int i = 0; i < controlArray.Length; i++)
{
ptr = Marshal.AllocHGlobal(cb);
Marshal.StructureToPtr(controlArray[i], ptr, false);
ptr6 = (IntPtr)(((long)zero) + (Marshal.SizeOf(typeof(IntPtr)) * i));
Marshal.WriteIntPtr(ptr6, ptr);
}
ptr6 = (IntPtr)(((long)zero) + (Marshal.SizeOf(typeof(IntPtr)) * controlArray.Length));
Marshal.WriteIntPtr(ptr6, IntPtr.Zero);
}
controlArray2 = this.connection.BuildControlArray(controls, false);
if (controlArray2 != null)
{
clientControls = Marshal.AllocHGlobal((int)(Marshal.SizeOf(typeof(IntPtr)) * (controlArray2.Length + 1)));
for (int j = 0; j < controlArray2.Length; j++)
{
ptr = Marshal.AllocHGlobal(cb);
Marshal.StructureToPtr(controlArray2[j], ptr, false);
ptr6 = (IntPtr)(((long)clientControls) + (Marshal.SizeOf(typeof(IntPtr)) * j));
Marshal.WriteIntPtr(ptr6, ptr);
}
ptr6 = (IntPtr)(((long)clientControls) + (Marshal.SizeOf(typeof(IntPtr)) * controlArray2.Length));
Marshal.WriteIntPtr(ptr6, IntPtr.Zero);
}
int errorCode = Wldap32.ldap_start_tls(this.connection.ldapHandle, ref serverReturnValue, ref message, zero, clientControls);
if (((message != IntPtr.Zero) && (Wldap32.ldap_parse_result_referral(this.connection.ldapHandle, message, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, ref referral, IntPtr.Zero, 0) == 0)) && (referral != IntPtr.Zero))
{
char ** chPtr = (char **)referral;
char * chPtr2 = chPtr[0];
int index = 0;
ArrayList list = new ArrayList();
while (chPtr2 != null)
{
string str = Marshal.PtrToStringUni((IntPtr)chPtr2);
list.Add(str);
index++;
chPtr2 = chPtr[index];
}
if (referral != IntPtr.Zero)
{
Wldap32.ldap_value_free(referral);
referral = IntPtr.Zero;
}
if (list.Count > 0)
{
uriArray = new Uri[list.Count];
for (int k = 0; k < list.Count; k++)
{
uriArray[k] = new Uri((string)list[k]);
}
}
}
if (errorCode != 0)
{
string str2 = Res.GetString("DefaultLdapError");
if (Utility.IsResultCode((ResultCode)errorCode))
{
if (errorCode == 80)
{
errorCode = serverReturnValue;
}
str2 = OperationErrorMappings.MapResultCode(errorCode);
ExtendedResponse response = new ExtendedResponse(null, null, (ResultCode)errorCode, str2, uriArray)
{
name = "1.3.6.1.4.1.1466.20037"
};
throw new TlsOperationException(response);
}
if (Utility.IsLdapError((LdapError)errorCode))
{
str2 = LdapErrorMappings.MapResultCode(errorCode);
throw new LdapException(errorCode, str2);
}
}
}
finally
{
if (zero != IntPtr.Zero)
{
for (int m = 0; m < controlArray.Length; m++)
{
IntPtr hglobal = Marshal.ReadIntPtr(zero, Marshal.SizeOf(typeof(IntPtr)) * m);
if (hglobal != IntPtr.Zero)
{
Marshal.FreeHGlobal(hglobal);
}
}
Marshal.FreeHGlobal(zero);
}
if (controlArray != null)
{
for (int n = 0; n < controlArray.Length; n++)
{
if (controlArray[n].ldctl_oid != IntPtr.Zero)
{
Marshal.FreeHGlobal(controlArray[n].ldctl_oid);
}
if ((controlArray[n].ldctl_value != null) && (controlArray[n].ldctl_value.bv_val != IntPtr.Zero))
{
Marshal.FreeHGlobal(controlArray[n].ldctl_value.bv_val);
}
}
}
if (clientControls != IntPtr.Zero)
{
for (int num11 = 0; num11 < controlArray2.Length; num11++)
{
IntPtr ptr8 = Marshal.ReadIntPtr(clientControls, Marshal.SizeOf(typeof(IntPtr)) * num11);
if (ptr8 != IntPtr.Zero)
{
Marshal.FreeHGlobal(ptr8);
}
}
Marshal.FreeHGlobal(clientControls);
}
if (controlArray2 != null)
{
for (int num12 = 0; num12 < controlArray2.Length; num12++)
{
if (controlArray2[num12].ldctl_oid != IntPtr.Zero)
{
Marshal.FreeHGlobal(controlArray2[num12].ldctl_oid);
}
if ((controlArray2[num12].ldctl_value != null) && (controlArray2[num12].ldctl_value.bv_val != IntPtr.Zero))
{
Marshal.FreeHGlobal(controlArray2[num12].ldctl_value.bv_val);
}
}
}
if (referral != IntPtr.Zero)
{
Wldap32.ldap_value_free(referral);
}
}
}
public unsafe void StartTransportLayerSecurity(DirectoryControlCollection controls)
{
IntPtr serverControlArray = (IntPtr)0;
LdapControl[] managedServerControls = null;
IntPtr clientControlArray = (IntPtr)0;
LdapControl[] managedClientControls = null;
IntPtr ldapResult = (IntPtr)0;
IntPtr referral = (IntPtr)0;
int serverError = 0;
Uri[] responseReferral = null;
if (_connection.disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
try
{
IntPtr controlPtr = (IntPtr)0;
IntPtr tempPtr = (IntPtr)0;
// build server control
managedServerControls = _connection.BuildControlArray(controls, true);
int structSize = Marshal.SizeOf(typeof(LdapControl));
if (managedServerControls != null)
{
serverControlArray = Utility.AllocHGlobalIntPtrArray(managedServerControls.Length + 1);
for (int i = 0; i < managedServerControls.Length; i++)
{
controlPtr = Marshal.AllocHGlobal(structSize);
Marshal.StructureToPtr(managedServerControls[i], controlPtr, false);
tempPtr = (IntPtr)((long)serverControlArray + IntPtr.Size * i);
Marshal.WriteIntPtr(tempPtr, controlPtr);
}
tempPtr = (IntPtr)((long)serverControlArray + IntPtr.Size * managedServerControls.Length);
Marshal.WriteIntPtr(tempPtr, (IntPtr)0);
}
// build client control
managedClientControls = _connection.BuildControlArray(controls, false);
if (managedClientControls != null)
{
clientControlArray = Utility.AllocHGlobalIntPtrArray(managedClientControls.Length + 1);
for (int i = 0; i < managedClientControls.Length; i++)
{
controlPtr = Marshal.AllocHGlobal(structSize);
Marshal.StructureToPtr(managedClientControls[i], controlPtr, false);
tempPtr = (IntPtr)((long)clientControlArray + IntPtr.Size * i);
Marshal.WriteIntPtr(tempPtr, controlPtr);
}
tempPtr = (IntPtr)((long)clientControlArray + IntPtr.Size * managedClientControls.Length);
Marshal.WriteIntPtr(tempPtr, (IntPtr)0);
}
int error = Wldap32.ldap_start_tls(_connection.ldapHandle, ref serverError, ref ldapResult, serverControlArray, clientControlArray);
if (ldapResult != (IntPtr)0)
{
// parsing the referral
int resulterror = Wldap32.ldap_parse_result_referral(_connection.ldapHandle, ldapResult, (IntPtr)0, (IntPtr)0, (IntPtr)0, ref referral, (IntPtr)0, 0 /* not free it */);
if (resulterror == 0)
{
// parsing referral
if (referral != (IntPtr)0)
{
char ** referralPtr = (char **)referral;
char * singleReferral = referralPtr[0];
int i = 0;
ArrayList referralList = new ArrayList();
while (singleReferral != null)
{
string s = Marshal.PtrToStringUni((IntPtr)singleReferral);
referralList.Add(s);
i++;
singleReferral = referralPtr[i];
}
// free heap memory
if (referral != (IntPtr)0)
{
Wldap32.ldap_value_free(referral);
referral = (IntPtr)0;
}
if (referralList.Count > 0)
{
responseReferral = new Uri[referralList.Count];
for (int j = 0; j < referralList.Count; j++)
{
responseReferral[j] = new Uri((string)referralList[j]);
}
}
}
}
}
if (error != (int)ResultCode.Success)
{
string errorMessage = String.Format(CultureInfo.CurrentCulture, SR.DefaultLdapError);
if (Utility.IsResultCode((ResultCode)error))
{
//If the server failed request for whatever reason, the ldap_start_tls returns LDAP_OTHER
// and the ServerReturnValue will contain the error code from the server.
if (error == (int)ResultCode.Other)
{
error = serverError;
}
errorMessage = OperationErrorMappings.MapResultCode(error);
ExtendedResponse response = new ExtendedResponse(null, null, (ResultCode)error, errorMessage, responseReferral);
response.ResponseName = "1.3.6.1.4.1.1466.20037";
throw new TlsOperationException(response);
}
else if (Utility.IsLdapError((LdapError)error))
{
errorMessage = LdapErrorMappings.MapResultCode(error);
throw new LdapException(error, errorMessage);
}
}
}
finally
{
if (serverControlArray != (IntPtr)0)
{
//release the memory from the heap
for (int i = 0; i < managedServerControls.Length; i++)
{
IntPtr tempPtr = Marshal.ReadIntPtr(serverControlArray, IntPtr.Size * i);
if (tempPtr != (IntPtr)0)
{
Marshal.FreeHGlobal(tempPtr);
}
}
Marshal.FreeHGlobal(serverControlArray);
}
if (managedServerControls != null)
{
for (int i = 0; i < managedServerControls.Length; i++)
{
if (managedServerControls[i].ldctl_oid != (IntPtr)0)
{
Marshal.FreeHGlobal(managedServerControls[i].ldctl_oid);
}
if (managedServerControls[i].ldctl_value != null)
{
if (managedServerControls[i].ldctl_value.bv_val != (IntPtr)0)
{
Marshal.FreeHGlobal(managedServerControls[i].ldctl_value.bv_val);
}
}
}
}
if (clientControlArray != (IntPtr)0)
{
// release the memor from the heap
for (int i = 0; i < managedClientControls.Length; i++)
{
IntPtr tempPtr = Marshal.ReadIntPtr(clientControlArray, IntPtr.Size * i);
if (tempPtr != (IntPtr)0)
{
Marshal.FreeHGlobal(tempPtr);
}
}
Marshal.FreeHGlobal(clientControlArray);
}
if (managedClientControls != null)
{
for (int i = 0; i < managedClientControls.Length; i++)
{
if (managedClientControls[i].ldctl_oid != (IntPtr)0)
{
Marshal.FreeHGlobal(managedClientControls[i].ldctl_oid);
}
if (managedClientControls[i].ldctl_value != null)
{
if (managedClientControls[i].ldctl_value.bv_val != (IntPtr)0)
{
Marshal.FreeHGlobal(managedClientControls[i].ldctl_value.bv_val);
}
}
}
}
if (referral != (IntPtr)0)
{
Wldap32.ldap_value_free(referral);
}
}
}
public unsafe void StartTransportLayerSecurity(DirectoryControlCollection controls)
{
IntPtr intPtr;
IntPtr intPtr1;
IntPtr intPtr2 = (IntPtr)0;
LdapControl[] ldapControlArray = null;
IntPtr intPtr3 = (IntPtr)0;
LdapControl[] ldapControlArray1 = null;
IntPtr intPtr4 = (IntPtr)0;
IntPtr intPtr5 = (IntPtr)0;
int num = 0;
Uri[] uri = null;
if (!Utility.IsWin2kOS)
{
if (!this.connection.disposed)
{
try
{
ldapControlArray = this.connection.BuildControlArray(controls, true);
int num1 = Marshal.SizeOf(typeof(LdapControl));
if (ldapControlArray != null)
{
intPtr2 = Utility.AllocHGlobalIntPtrArray((int)ldapControlArray.Length + 1);
for (int i = 0; i < (int)ldapControlArray.Length; i++)
{
intPtr = Marshal.AllocHGlobal(num1);
Marshal.StructureToPtr(ldapControlArray[i], intPtr, false);
intPtr1 = (IntPtr)((long)intPtr2 + (long)(Marshal.SizeOf(typeof(IntPtr)) * i));
Marshal.WriteIntPtr(intPtr1, intPtr);
}
intPtr1 = (IntPtr)((long)intPtr2 + (long)(Marshal.SizeOf(typeof(IntPtr)) * (int)ldapControlArray.Length));
Marshal.WriteIntPtr(intPtr1, (IntPtr)0);
}
ldapControlArray1 = this.connection.BuildControlArray(controls, false);
if (ldapControlArray1 != null)
{
intPtr3 = Utility.AllocHGlobalIntPtrArray((int)ldapControlArray1.Length + 1);
for (int j = 0; j < (int)ldapControlArray1.Length; j++)
{
intPtr = Marshal.AllocHGlobal(num1);
Marshal.StructureToPtr(ldapControlArray1[j], intPtr, false);
intPtr1 = (IntPtr)((long)intPtr3 + (long)(Marshal.SizeOf(typeof(IntPtr)) * j));
Marshal.WriteIntPtr(intPtr1, intPtr);
}
intPtr1 = (IntPtr)((long)intPtr3 + (long)(Marshal.SizeOf(typeof(IntPtr)) * (int)ldapControlArray1.Length));
Marshal.WriteIntPtr(intPtr1, (IntPtr)0);
}
int num2 = Wldap32.ldap_start_tls(this.connection.ldapHandle, ref num, ref intPtr4, intPtr2, intPtr3);
if (intPtr4 != (IntPtr)0)
{
int num3 = Wldap32.ldap_parse_result_referral(this.connection.ldapHandle, intPtr4, (IntPtr)0, (IntPtr)0, (IntPtr)0, ref intPtr5, (IntPtr)0, 0);
if (num3 == 0 && intPtr5 != (IntPtr)0)
{
char ** chrPointer = (char **)((void *)intPtr5);
char * chrPointer1 = (char *)((void *)(*(chrPointer)));
int num4 = 0;
ArrayList arrayLists = new ArrayList();
while (chrPointer1 != null)
{
string stringUni = Marshal.PtrToStringUni((IntPtr)chrPointer1);
arrayLists.Add(stringUni);
num4++;
chrPointer1 = (char *)((void *)(*(chrPointer + num4 * sizeof(char *))));
}
if (intPtr5 != (IntPtr)0)
{
Wldap32.ldap_value_free(intPtr5);
intPtr5 = (IntPtr)0;
}
if (arrayLists.Count > 0)
{
uri = new Uri[arrayLists.Count];
for (int k = 0; k < arrayLists.Count; k++)
{
uri[k] = new Uri((string)arrayLists[k]);
}
}
}
}
if (num2 != 0)
{
string str = Res.GetString("DefaultLdapError");
if (!Utility.IsResultCode((ResultCode)num2))
{
if (Utility.IsLdapError((LdapError)num2))
{
str = LdapErrorMappings.MapResultCode(num2);
throw new LdapException(num2, str);
}
}
else
{
if (num2 == 80)
{
num2 = num;
}
str = OperationErrorMappings.MapResultCode(num2);
ExtendedResponse extendedResponse = new ExtendedResponse(null, null, (ResultCode)num2, str, uri);
extendedResponse.name = "1.3.6.1.4.1.1466.20037";
throw new TlsOperationException(extendedResponse);
}
}
}
finally
{
if (intPtr2 != (IntPtr)0)
{
for (int l = 0; l < (int)ldapControlArray.Length; l++)
{
IntPtr intPtr6 = Marshal.ReadIntPtr(intPtr2, Marshal.SizeOf(typeof(IntPtr)) * l);
if (intPtr6 != (IntPtr)0)
{
Marshal.FreeHGlobal(intPtr6);
}
}
Marshal.FreeHGlobal(intPtr2);
}
if (ldapControlArray != null)
{
for (int m = 0; m < (int)ldapControlArray.Length; m++)
{
if (ldapControlArray[m].ldctl_oid != (IntPtr)0)
{
Marshal.FreeHGlobal(ldapControlArray[m].ldctl_oid);
}
if (ldapControlArray[m].ldctl_value != null && ldapControlArray[m].ldctl_value.bv_val != (IntPtr)0)
{
Marshal.FreeHGlobal(ldapControlArray[m].ldctl_value.bv_val);
}
}
}
if (intPtr3 != (IntPtr)0)
{
for (int n = 0; n < (int)ldapControlArray1.Length; n++)
{
IntPtr intPtr7 = Marshal.ReadIntPtr(intPtr3, Marshal.SizeOf(typeof(IntPtr)) * n);
if (intPtr7 != (IntPtr)0)
{
Marshal.FreeHGlobal(intPtr7);
}
}
Marshal.FreeHGlobal(intPtr3);
}
if (ldapControlArray1 != null)
{
for (int o = 0; o < (int)ldapControlArray1.Length; o++)
{
if (ldapControlArray1[o].ldctl_oid != (IntPtr)0)
{
Marshal.FreeHGlobal(ldapControlArray1[o].ldctl_oid);
}
if (ldapControlArray1[o].ldctl_value != null && ldapControlArray1[o].ldctl_value.bv_val != (IntPtr)0)
{
Marshal.FreeHGlobal(ldapControlArray1[o].ldctl_value.bv_val);
}
}
}
if (intPtr5 != (IntPtr)0)
{
Wldap32.ldap_value_free(intPtr5);
}
}
return;
}
else
{
throw new ObjectDisposedException(this.GetType().Name);
}
}
else
{
throw new PlatformNotSupportedException(Res.GetString("TLSNotSupported"));
}
}
