コード例 #1
0
        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);
                }
            }
        }
コード例 #2
0
        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);
        }
コード例 #3
0
ファイル: LdapException.cs プロジェクト: zealousfool/corefx
 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);
         }
     }
 }
コード例 #4
0
        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));
                }
            }
        }
コード例 #5
0
 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");
     }
 }
コード例 #6
0
        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);
                }
            }
        }
コード例 #7
0
        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);
                }
            }
        }
コード例 #8
0
        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"));
            }
        }