コード例 #1
0
 public void AddRange(DirectoryControlCollection controlCollection)
 {
     foreach (var c in controlCollection)
     {
         List.Add(c);
     }
 }
 public void AddRange(DirectoryControlCollection controlCollection)
 {
     if (controlCollection == null)
     {
         throw new ArgumentNullException("controlCollection");
     }
     int count = controlCollection.Count;
     for (int i = 0; i < count; i++)
     {
         this.Add(controlCollection[i]);
     }
 }
コード例 #3
0
 public void AddRange(DirectoryControlCollection controlCollection)
 {
     if (controlCollection == null)
     {
         throw new ArgumentNullException("controlCollection");
     }
     int currentCount = controlCollection.Count;
     for (int i = 0; i < currentCount; i = ((i) + (1)))
     {
         this.Add(controlCollection[i]);
     }
 }
コード例 #4
0
 public void AddRange(DirectoryControlCollection controlCollection)
 {
     if (controlCollection != null)
     {
         int count = controlCollection.Count;
         for (int i = 0; i < count; i++)
         {
             this.Add(controlCollection[i]);
         }
         return;
     }
     else
     {
         throw new ArgumentNullException("controlCollection");
     }
 }
コード例 #5
0
 internal DirectoryRequest()
 {
     Utility.CheckOSVersion();
     this.directoryControlCollection = new DirectoryControlCollection();
 }
コード例 #6
0
ファイル: DirectoryRequest.cs プロジェクト: nlhepler/mono
		internal DirectoryRequest ()
		{
			Controls = new DirectoryControlCollection ();
		}
コード例 #7
0
ファイル: LdapSessionOptions.cs プロジェクト: nickchal/pash
		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"));
			}
		}
コード例 #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"));
            }
        }
コード例 #9
0
 public void StartTransportLayerSecurity(DirectoryControlCollection controls)
 {
     throw new NotImplementedException();
 }
コード例 #10
0
 internal LdapControl[] BuildControlArray(DirectoryControlCollection controls, bool serverControl)
 {
     int count = 0;
     LdapControl[] controlArray = null;
     if ((controls != null) && (controls.Count != 0))
     {
         ArrayList list = new ArrayList();
         foreach (DirectoryControl control in controls)
         {
             if (serverControl)
             {
                 if (control.ServerSide)
                 {
                     list.Add(control);
                 }
             }
             else if (!control.ServerSide)
             {
                 list.Add(control);
             }
         }
         if (list.Count == 0)
         {
             return controlArray;
         }
         count = list.Count;
         controlArray = new LdapControl[count];
         for (int i = 0; i < count; i++)
         {
             controlArray[i] = new LdapControl();
             controlArray[i].ldctl_oid = Marshal.StringToHGlobalUni(((DirectoryControl) list[i]).Type);
             controlArray[i].ldctl_iscritical = ((DirectoryControl) list[i]).IsCritical;
             byte[] source = ((DirectoryControl) list[i]).GetValue();
             if ((source == null) || (source.Length == 0))
             {
                 controlArray[i].ldctl_value = new berval();
                 controlArray[i].ldctl_value.bv_len = 0;
                 controlArray[i].ldctl_value.bv_val = IntPtr.Zero;
             }
             else
             {
                 controlArray[i].ldctl_value = new berval();
                 controlArray[i].ldctl_value.bv_len = source.Length;
                 controlArray[i].ldctl_value.bv_val = Marshal.AllocHGlobal((int) (Marshal.SizeOf(typeof(byte)) * controlArray[i].ldctl_value.bv_len));
                 Marshal.Copy(source, 0, controlArray[i].ldctl_value.bv_val, controlArray[i].ldctl_value.bv_len);
             }
         }
     }
     return controlArray;
 }
 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);
         }
     }
 }
コード例 #12
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);
                }
            }
        }
コード例 #13
0
ファイル: LdapSessionOptions.cs プロジェクト: chcosta/corefx
        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 (Utility.IsWin2kOS)
                throw new PlatformNotSupportedException(Res.GetString(Res.TLSNotSupported));

            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 + Marshal.SizeOf(typeof(IntPtr)) * i);
                        Marshal.WriteIntPtr(tempPtr, controlPtr);
                    }

                    tempPtr = (IntPtr)((long)serverControlArray + Marshal.SizeOf(typeof(IntPtr)) * 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 + Marshal.SizeOf(typeof(IntPtr)) * i);
                        Marshal.WriteIntPtr(tempPtr, controlPtr);
                    }
                    tempPtr = (IntPtr)((long)clientControlArray + Marshal.SizeOf(typeof(IntPtr)) * 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 = Res.GetString(Res.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.name = "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, Marshal.SizeOf(typeof(IntPtr)) * 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, Marshal.SizeOf(typeof(IntPtr)) * 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);
            }
        }
コード例 #14
0
ファイル: DirectoryRequest.cs プロジェクト: nickchal/pash
		internal DirectoryRequest()
		{
			Utility.CheckOSVersion();
			this.directoryControlCollection = new DirectoryControlCollection();
		}
        public unsafe void StartTransportLayerSecurity(DirectoryControlCollection controls)
        {
            IntPtr serverControlArray = IntPtr.Zero;

            LdapControl[] managedServerControls = null;
            IntPtr        clientControlArray    = IntPtr.Zero;

            LdapControl[] managedClientControls = null;
            //IntPtr ldapResult = IntPtr.Zero;
            //IntPtr referral = IntPtr.Zero;

            //int serverError = 0;
            //Uri[] responseReferral = null;

            if (_connection._disposed)
            {
                throw new ObjectDisposedException(GetType().Name);
            }

            try
            {
                IntPtr tempPtr = IntPtr.Zero;

                // 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++)
                    {
                        IntPtr 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.Zero);
                }

                // 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++)
                    {
                        IntPtr 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.Zero);
                }

                // requested certificate.
                //  - no certificate = no problem.
                //  - bad certificate = no problem
                var require_cert = (int)LDAP_OPT_X_TLS.ALLOW;
                Wldap32.ldap_set_option_int(_connection._ldapHandle, LdapOption.LDAP_OPT_X_TLS_REQUIRE_CERT, ref require_cert);
                //new tls client context
                var off = 0;
                Wldap32.ldap_set_option_int(_connection._ldapHandle, LdapOption.LDAP_OPT_X_TLS_NEWCTX, ref off);

                //var test tls connect callback
                var result = Wldap32.ldap_set_option_TLS_CONNECT_CB(_connection._ldapHandle, LdapOption.LDAP_OPT_X_TLS_CONNECT_CB, _routine);



                int error = Wldap32.ldap_start_tls(_connection._ldapHandle, serverControlArray, clientControlArray);


                //IntPtr ret1 = IntPtr.Zero;
                //Wldap32.ldap_get_option_ptr(_connection._ldapHandle, LdapOption.LDAP_OPT_X_TLS_CACERTFILE, ref ret1);
                //Console.WriteLine(Encoding.PtrToStringUTF8(ret1));

                //typedef int (LDAP_TLS_CONNECT_CB) LDAP_P (( struct ldap *ld, void *ssl, void *ctx, void *arg ));


                //TODO: check referrals equivalent with openldap

                /*                if (ldapResult != IntPtr.Zero)
                 *              {
                 *                  // Parse the referral.
                 *                  int resultError = Wldap32.ldap_parse_result_referral(_connection._ldapHandle, ldapResult, IntPtr.Zero, IntPtr.Zero, IntPtr.Zero, ref referral, IntPtr.Zero, 0  );
                 *                  if (resultError == 0 && referral != IntPtr.Zero)
                 *                  {
                 *                      char** referralPtr = (char**)referral;
                 *                      char* singleReferral = referralPtr[0];
                 *                      int i = 0;
                 *                      ArrayList referralList = new ArrayList();
                 *                      while (singleReferral != null)
                 *                      {
                 *                          string s = Encoding.PtrToString((IntPtr)singleReferral);
                 *                          referralList.Add(s);
                 *
                 *                          i++;
                 *                          singleReferral = referralPtr[i];
                 *                      }
                 *
                 *                      // Free heap memory.
                 *                      if (referral != IntPtr.Zero)
                 *                      {
                 *                          Wldap32.ldap_value_free(referral);
                 *                          referral = IntPtr.Zero;
                 *                      }
                 *
                 *                      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 errorText = Encoding.PtrToString(Wldap32.ldap_err2string(error));

                    string errorAdditional = GetStringValueHelper(LdapOption.LDAP_OPT_DIAGNOSTIC_MESSAGE, true);

                    if (error > 0)
                    {
                        //positive, indicating an LDAP resultCode other than 'success'

                        ExtendedResponse response = new ExtendedResponse(null, null, (ResultCode)error, errorText, null);
                        response.ResponseName = "1.3.6.1.4.1.1466.20037";
                        throw new TlsOperationException(response);
                    }
                    else if (error < 0)
                    {
                        //negative, indicating an API error code;
                        error = Math.Abs(error) + 80; //convert negative number for exception for compatibilty with original S.DS.P
                        throw new LdapException(error, errorText, errorAdditional);
                    }
                }
            }
            finally
            {
                if (serverControlArray != IntPtr.Zero)
                {
                    // 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.Zero)
                        {
                            Marshal.FreeHGlobal(tempPtr);
                        }
                    }
                    Marshal.FreeHGlobal(serverControlArray);
                }

                if (managedServerControls != null)
                {
                    for (int i = 0; i < managedServerControls.Length; i++)
                    {
                        if (managedServerControls[i].ldctl_oid != IntPtr.Zero)
                        {
                            Marshal.FreeHGlobal(managedServerControls[i].ldctl_oid);
                        }

                        if (managedServerControls[i].ldctl_value != null)
                        {
                            if (managedServerControls[i].ldctl_value.bv_val != IntPtr.Zero)
                            {
                                Marshal.FreeHGlobal(managedServerControls[i].ldctl_value.bv_val);
                            }
                        }
                    }
                }

                if (clientControlArray != IntPtr.Zero)
                {
                    // 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.Zero)
                        {
                            Marshal.FreeHGlobal(tempPtr);
                        }
                    }

                    Marshal.FreeHGlobal(clientControlArray);
                }

                if (managedClientControls != null)
                {
                    for (int i = 0; i < managedClientControls.Length; i++)
                    {
                        if (managedClientControls[i].ldctl_oid != IntPtr.Zero)
                        {
                            Marshal.FreeHGlobal(managedClientControls[i].ldctl_oid);
                        }

                        if (managedClientControls[i].ldctl_value != null)
                        {
                            if (managedClientControls[i].ldctl_value.bv_val != IntPtr.Zero)
                            {
                                Marshal.FreeHGlobal(managedClientControls[i].ldctl_value.bv_val);
                            }
                        }
                    }
                }

                /*if (referral != IntPtr.Zero)
                 * {
                 *  Wldap32.ldap_value_free(referral);
                 * }*/
            }
        }
コード例 #16
0
		public void AddRange (DirectoryControlCollection controlCollection)
		{
			foreach (var c in controlCollection)
				List.Add (c);
		}
コード例 #17
0
ファイル: LdapSessionOptions.cs プロジェクト: nlhepler/mono
		public void StartTransportLayerSecurity (DirectoryControlCollection controls)
		{
			throw new NotImplementedException ();
		}
コード例 #18
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);
                }
            }
        }
コード例 #19
0
ファイル: LdapConnection.cs プロジェクト: nickchal/pash
		internal LdapControl[] BuildControlArray(DirectoryControlCollection controls, bool serverControl)
		{
			LdapControl[] ldapControl = null;
			if (controls != null && controls.Count != 0)
			{
				ArrayList arrayLists = new ArrayList();
				foreach (DirectoryControl control in controls)
				{
					if (!serverControl)
					{
						if (control.ServerSide)
						{
							continue;
						}
						arrayLists.Add(control);
					}
					else
					{
						if (!control.ServerSide)
						{
							continue;
						}
						arrayLists.Add(control);
					}
				}
				if (arrayLists.Count != 0)
				{
					int count = arrayLists.Count;
					ldapControl = new LdapControl[count];
					for (int i = 0; i < count; i++)
					{
						ldapControl[i] = new LdapControl();
						ldapControl[i].ldctl_oid = Marshal.StringToHGlobalUni(((DirectoryControl)arrayLists[i]).Type);
						ldapControl[i].ldctl_iscritical = ((DirectoryControl)arrayLists[i]).IsCritical;
						DirectoryControl item = (DirectoryControl)arrayLists[i];
						byte[] value = item.GetValue();
						if (value == null || (int)value.Length == 0)
						{
							ldapControl[i].ldctl_value = new berval();
							ldapControl[i].ldctl_value.bv_len = 0;
							ldapControl[i].ldctl_value.bv_val = (IntPtr)0;
						}
						else
						{
							ldapControl[i].ldctl_value = new berval();
							ldapControl[i].ldctl_value.bv_len = (int)value.Length;
							ldapControl[i].ldctl_value.bv_val = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(byte)) * ldapControl[i].ldctl_value.bv_len);
							Marshal.Copy(value, 0, ldapControl[i].ldctl_value.bv_val, ldapControl[i].ldctl_value.bv_len);
						}
					}
				}
			}
			return ldapControl;
		}
コード例 #20
0
ファイル: LdapConnection.cs プロジェクト: chcosta/corefx
        internal LdapControl[] BuildControlArray(DirectoryControlCollection controls, bool serverControl)
        {
            int count = 0;
            LdapControl[] managedControls = null;

            if (controls != null && controls.Count != 0)
            {
                ArrayList controlList = new ArrayList();
                foreach (DirectoryControl col in controls)
                {
                    if (serverControl == true)
                    {
                        if (col.ServerSide)
                            controlList.Add(col);
                    }
                    else
                    {
                        if (!col.ServerSide)
                            controlList.Add(col);
                    }
                }
                if (controlList.Count != 0)
                {
                    count = controlList.Count;

                    managedControls = new LdapControl[count];

                    for (int i = 0; i < count; i++)
                    {
                        managedControls[i] = new LdapControl();
                        // get the control type
                        managedControls[i].ldctl_oid = Marshal.StringToHGlobalUni(((DirectoryControl)controlList[i]).Type);
                        //get the control cricality
                        managedControls[i].ldctl_iscritical = ((DirectoryControl)controlList[i]).IsCritical;
                        // get the control value
                        DirectoryControl tempControl = (DirectoryControl)controlList[i];
                        byte[] byteControlValue = tempControl.GetValue();
                        if (byteControlValue == null || byteControlValue.Length == 0)
                        {
                            // treat the control value as null
                            managedControls[i].ldctl_value = new berval();
                            managedControls[i].ldctl_value.bv_len = 0;
                            managedControls[i].ldctl_value.bv_val = (IntPtr)0;
                        }
                        else
                        {
                            managedControls[i].ldctl_value = new berval();
                            managedControls[i].ldctl_value.bv_len = byteControlValue.Length;
                            managedControls[i].ldctl_value.bv_val = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(byte)) * managedControls[i].ldctl_value.bv_len);
                            Marshal.Copy(byteControlValue, 0, managedControls[i].ldctl_value.bv_val, managedControls[i].ldctl_value.bv_len);
                        }
                    }
                }
            }

            return managedControls;
        }
コード例 #21
0
ファイル: DirectoryRequest.cs プロジェクト: pmq20/mono_forked
 internal DirectoryRequest()
 {
     Controls = new DirectoryControlCollection();
 }