예제 #1
0
        public int IndexOf(TopLevelName name)
        {
            if (name == null)
                throw new ArgumentNullException("name");

            return InnerList.IndexOf(name);
        }
예제 #2
0
        internal int Add(TopLevelName name)
        {
            if (name == null)
                throw new ArgumentNullException("name");

            return InnerList.Add(name);
        }
예제 #3
0
        public bool Contains(TopLevelName name)
        {
            if (name == null)
                throw new ArgumentNullException("name");

            return InnerList.Contains(name);
        }
 internal int Add(TopLevelName name)
 {
     if (name == null)
     {
         throw new ArgumentNullException("name");
     }
     return(base.InnerList.Add(name));
 }
 public bool Contains(TopLevelName name)
 {
     if (name == null)
     {
         throw new ArgumentNullException("name");
     }
     return(base.InnerList.Contains(name));
 }
 public int IndexOf(TopLevelName name)
 {
     if (name == null)
     {
         throw new ArgumentNullException("name");
     }
     return(base.InnerList.IndexOf(name));
 }
    public int IndexOf(TopLevelName name)
    {
      Contract.Requires(name != null);
      Contract.Ensures(Contract.Result<int>() >= -1);
      Contract.Ensures(Contract.Result<int>() < this.Count);

      return default(int);
    }
        public int IndexOf(TopLevelName name)
        {
            Contract.Requires(name != null);
            Contract.Ensures(Contract.Result <int>() >= -1);
            Contract.Ensures(Contract.Result <int>() < this.Count);

            return(default(int));
        }
예제 #9
0
		public int IndexOf(TopLevelName name)
		{
			if (name != null)
			{
				return base.InnerList.IndexOf(name);
			}
			else
			{
				throw new ArgumentNullException("name");
			}
		}
예제 #10
0
		public bool Contains(TopLevelName name)
		{
			if (name != null)
			{
				return base.InnerList.Contains(name);
			}
			else
			{
				throw new ArgumentNullException("name");
			}
		}
예제 #11
0
		internal int Add(TopLevelName name)
		{
			if (name != null)
			{
				return base.InnerList.Add(name);
			}
			else
			{
				throw new ArgumentNullException("name");
			}
		}
예제 #12
0
 public void CopyTo(TopLevelName[] names, int index)
 {
     InnerList.CopyTo(names, index);
 }
        public bool Contains(TopLevelName name)
        {
            Contract.Requires(name != null);

            return(default(bool));
        }
예제 #14
0
 public int IndexOf(TopLevelName name)
 {
     throw new NotImplementedException();
 }
예제 #15
0
 public bool Contains(TopLevelName name)
 {
     throw new NotImplementedException();
 }
		private void GetForestTrustInfoHelper()
		{
			IntPtr intPtr = (IntPtr)0;
			bool flag = false;
			IntPtr hGlobalUni = (IntPtr)0;
			TopLevelNameCollection topLevelNameCollection = new TopLevelNameCollection();
			StringCollection stringCollections = new StringCollection();
			ForestTrustDomainInfoCollection forestTrustDomainInfoCollection = new ForestTrustDomainInfoCollection();
			ArrayList arrayLists = new ArrayList();
			Hashtable hashtables = new Hashtable();
			ArrayList arrayLists1 = new ArrayList();
			try
			{
				try
				{
					LSA_UNICODE_STRING lSAUNICODESTRING = new LSA_UNICODE_STRING();
					hGlobalUni = Marshal.StringToHGlobalUni(base.TargetName);
					UnsafeNativeMethods.RtlInitUnicodeString(lSAUNICODESTRING, hGlobalUni);
					string policyServerName = Utils.GetPolicyServerName(this.context, true, false, this.source);
					flag = Utils.Impersonate(this.context);
					PolicySafeHandle policySafeHandle = new PolicySafeHandle(Utils.GetPolicyHandle(policyServerName));
					int num = UnsafeNativeMethods.LsaQueryForestTrustInformation(policySafeHandle, lSAUNICODESTRING, ref intPtr);
					if (num != 0)
					{
						int winError = UnsafeNativeMethods.LsaNtStatusToWinError(num);
						if (winError != 0)
						{
							throw ExceptionHelper.GetExceptionFromErrorCode(winError, policyServerName);
						}
					}
					try
					{
						if (intPtr != (IntPtr)0)
						{
							LSA_FOREST_TRUST_INFORMATION lSAFORESTTRUSTINFORMATION = new LSA_FOREST_TRUST_INFORMATION();
							Marshal.PtrToStructure(intPtr, lSAFORESTTRUSTINFORMATION);
							int recordCount = lSAFORESTTRUSTINFORMATION.RecordCount;
							for (int i = 0; i < recordCount; i++)
							{
								IntPtr intPtr1 = Marshal.ReadIntPtr(lSAFORESTTRUSTINFORMATION.Entries, i * Marshal.SizeOf(typeof(IntPtr)));
								LSA_FOREST_TRUST_RECORD lSAFORESTTRUSTRECORD = new LSA_FOREST_TRUST_RECORD();
								Marshal.PtrToStructure(intPtr1, lSAFORESTTRUSTRECORD);
								if (lSAFORESTTRUSTRECORD.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelName)
								{
									if (lSAFORESTTRUSTRECORD.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelNameEx)
									{
										if (lSAFORESTTRUSTRECORD.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustDomainInfo)
										{
											if (lSAFORESTTRUSTRECORD.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustRecordTypeLast)
											{
												int length = lSAFORESTTRUSTRECORD.Data.Length;
												byte[] numArray = new byte[length];
												if (lSAFORESTTRUSTRECORD.Data.Buffer != (IntPtr)0 && length != 0)
												{
													Marshal.Copy(lSAFORESTTRUSTRECORD.Data.Buffer, numArray, 0, length);
												}
												arrayLists.Add(numArray);
												arrayLists1.Add(lSAFORESTTRUSTRECORD.Time);
											}
										}
										else
										{
											ForestTrustDomainInformation forestTrustDomainInformation = new ForestTrustDomainInformation(lSAFORESTTRUSTRECORD.Flags, lSAFORESTTRUSTRECORD.DomainInfo, lSAFORESTTRUSTRECORD.Time);
											forestTrustDomainInfoCollection.Add(forestTrustDomainInformation);
										}
									}
									else
									{
										IntPtr intPtr2 = (IntPtr)((long)intPtr1 + (long)16);
										Marshal.PtrToStructure(intPtr2, lSAFORESTTRUSTRECORD.TopLevelName);
										string stringUni = Marshal.PtrToStringUni(lSAFORESTTRUSTRECORD.TopLevelName.Buffer, lSAFORESTTRUSTRECORD.TopLevelName.Length / 2);
										stringCollections.Add(stringUni);
										hashtables.Add(stringUni, lSAFORESTTRUSTRECORD.Time);
									}
								}
								else
								{
									IntPtr intPtr3 = (IntPtr)((long)intPtr1 + (long)16);
									Marshal.PtrToStructure(intPtr3, lSAFORESTTRUSTRECORD.TopLevelName);
									TopLevelName topLevelName = new TopLevelName(lSAFORESTTRUSTRECORD.Flags, lSAFORESTTRUSTRECORD.TopLevelName, lSAFORESTTRUSTRECORD.Time);
									topLevelNameCollection.Add(topLevelName);
								}
							}
						}
					}
					finally
					{
						UnsafeNativeMethods.LsaFreeMemory(intPtr);
					}
					this.topLevelNames = topLevelNameCollection;
					this.excludedNames = stringCollections;
					this.domainInfo = forestTrustDomainInfoCollection;
					this.binaryData = arrayLists;
					this.excludedNameTime = hashtables;
					this.binaryDataTime = arrayLists1;
					this.retrieved = true;
				}
				finally
				{
					if (flag)
					{
						Utils.Revert();
					}
					if (hGlobalUni != (IntPtr)0)
					{
						Marshal.FreeHGlobal(hGlobalUni);
					}
				}
			}
			catch
			{
				throw;
			}
		}
        private void GetForestTrustInfoHelper()
        {
            IntPtr forestTrustInfo = (IntPtr)0;
            PolicySafeHandle handle = null;
            LSA_UNICODE_STRING tmpName = null;
            bool impersonated = false;
            IntPtr targetPtr = (IntPtr)0;
            string serverName = null;

            TopLevelNameCollection tmpTLNs = new TopLevelNameCollection();
            StringCollection tmpExcludedTLNs = new StringCollection();
            ForestTrustDomainInfoCollection tmpDomainInformation = new ForestTrustDomainInfoCollection();

            // internal members
            ArrayList tmpBinaryData = new ArrayList();
            Hashtable tmpExcludedNameTime = new Hashtable();
            ArrayList tmpBinaryDataTime = new ArrayList();

            try
            {
                try
                {
                    // get the target name
                    tmpName = new LSA_UNICODE_STRING();
                    targetPtr = Marshal.StringToHGlobalUni(TargetName);
                    UnsafeNativeMethods.RtlInitUnicodeString(tmpName, targetPtr);

                    serverName = Utils.GetPolicyServerName(context, true, false, source);

                    // do impersonation
                    impersonated = Utils.Impersonate(context);

                    // get the policy handle
                    handle = new PolicySafeHandle(Utils.GetPolicyHandle(serverName));

                    int result = UnsafeNativeMethods.LsaQueryForestTrustInformation(handle, tmpName, ref forestTrustInfo);
                    // check the result
                    if (result != 0)
                    {
                        int win32Error = UnsafeNativeMethods.LsaNtStatusToWinError(result);
                        if (win32Error != 0)
                        {
                            throw ExceptionHelper.GetExceptionFromErrorCode(win32Error, serverName);
                        }
                    }

                    try
                    {
                        if (forestTrustInfo != (IntPtr)0)
                        {
                            LSA_FOREST_TRUST_INFORMATION trustInfo = new LSA_FOREST_TRUST_INFORMATION();
                            Marshal.PtrToStructure(forestTrustInfo, trustInfo);

                            int count = trustInfo.RecordCount;
                            IntPtr addr = (IntPtr)0;
                            for (int i = 0; i < count; i++)
                            {
                                addr = Marshal.ReadIntPtr(trustInfo.Entries, i * Marshal.SizeOf(typeof(IntPtr)));
                                LSA_FOREST_TRUST_RECORD record = new LSA_FOREST_TRUST_RECORD();
                                Marshal.PtrToStructure(addr, record);

                                if (record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelName)
                                {
                                    IntPtr myPtr = IntPtr.Add(addr, 16);
                                    Marshal.PtrToStructure(myPtr, record.TopLevelName);
                                    TopLevelName TLN = new TopLevelName(record.Flags, record.TopLevelName, record.Time);
                                    tmpTLNs.Add(TLN);
                                }
                                else if (record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelNameEx)
                                {
                                    // get the excluded TLN and put it in our collection
                                    IntPtr myPtr = IntPtr.Add(addr, 16);
                                    Marshal.PtrToStructure(myPtr, record.TopLevelName);
                                    string excludedName = Marshal.PtrToStringUni(record.TopLevelName.Buffer, record.TopLevelName.Length / 2);
                                    tmpExcludedTLNs.Add(excludedName);
                                    tmpExcludedNameTime.Add(excludedName, record.Time);
                                }
                                else if (record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustDomainInfo)
                                {
                                    ForestTrustDomainInformation dom = new ForestTrustDomainInformation(record.Flags, record.DomainInfo, record.Time);
                                    tmpDomainInformation.Add(dom);
                                }
                                else if (record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustRecordTypeLast)
                                {
                                    // enumeration is done, but we might still have some unrecognized entries after that
                                    continue;
                                }
                                else
                                {
                                    int length = record.Data.Length;
                                    byte[] byteArray = new byte[length];
                                    if ((record.Data.Buffer != (IntPtr)0) && (length != 0))
                                    {
                                        Marshal.Copy(record.Data.Buffer, byteArray, 0, length);
                                    }
                                    tmpBinaryData.Add(byteArray);
                                    tmpBinaryDataTime.Add(record.Time);
                                }
                            }
                        }
                    }
                    finally
                    {
                        UnsafeNativeMethods.LsaFreeMemory(forestTrustInfo);
                    }

                    _topLevelNames = tmpTLNs;
                    _excludedNames = tmpExcludedTLNs;
                    _domainInfo = tmpDomainInformation;

                    _binaryData = tmpBinaryData;
                    _excludedNameTime = tmpExcludedNameTime;
                    _binaryDataTime = tmpBinaryDataTime;

                    // mark it as retrieved
                    retrieved = true;
                }
                finally
                {
                    if (impersonated)
                        Utils.Revert();

                    if (targetPtr != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(targetPtr);
                    }
                }
            }
            catch { throw; }
        }
예제 #18
0
		public bool Contains (TopLevelName name)
		{
			throw new NotImplementedException ();
		}
    public void CopyTo(TopLevelName[] names, int index)
    {
      Contract.Requires(names != null);
      Contract.Requires(index >= 0);

    }
예제 #20
0
		public int IndexOf (TopLevelName name)
		{
			throw new NotImplementedException ();
		}
예제 #21
0
        private void GetForestTrustInfoHelper()
        {
            IntPtr             forestTrustInfo = (IntPtr)0;
            PolicySafeHandle   handle          = null;
            LSA_UNICODE_STRING tmpName         = null;
            bool   impersonated = false;
            IntPtr targetPtr    = (IntPtr)0;
            string serverName   = null;

            TopLevelNameCollection          tmpTLNs              = new TopLevelNameCollection();
            StringCollection                tmpExcludedTLNs      = new StringCollection();
            ForestTrustDomainInfoCollection tmpDomainInformation = new ForestTrustDomainInfoCollection();

            // internal members
            ArrayList tmpBinaryData       = new ArrayList();
            Hashtable tmpExcludedNameTime = new Hashtable();
            ArrayList tmpBinaryDataTime   = new ArrayList();

            try
            {
                try
                {
                    // get the target name
                    tmpName   = new LSA_UNICODE_STRING();
                    targetPtr = Marshal.StringToHGlobalUni(TargetName);
                    UnsafeNativeMethods.RtlInitUnicodeString(tmpName, targetPtr);

                    serverName = Utils.GetPolicyServerName(context, true, false, source);

                    // do impersonation
                    impersonated = Utils.Impersonate(context);

                    // get the policy handle
                    handle = new PolicySafeHandle(Utils.GetPolicyHandle(serverName));

                    int result = UnsafeNativeMethods.LsaQueryForestTrustInformation(handle, tmpName, ref forestTrustInfo);
                    // check the result
                    if (result != 0)
                    {
                        int win32Error = UnsafeNativeMethods.LsaNtStatusToWinError(result);
                        if (win32Error != 0)
                        {
                            throw ExceptionHelper.GetExceptionFromErrorCode(win32Error, serverName);
                        }
                    }

                    try
                    {
                        if (forestTrustInfo != (IntPtr)0)
                        {
                            LSA_FOREST_TRUST_INFORMATION trustInfo = new LSA_FOREST_TRUST_INFORMATION();
                            Marshal.PtrToStructure(forestTrustInfo, trustInfo);

                            int    count = trustInfo.RecordCount;
                            IntPtr addr  = (IntPtr)0;
                            for (int i = 0; i < count; i++)
                            {
                                addr = Marshal.ReadIntPtr(trustInfo.Entries, i * Marshal.SizeOf(typeof(IntPtr)));
                                LSA_FOREST_TRUST_RECORD record = new LSA_FOREST_TRUST_RECORD();
                                Marshal.PtrToStructure(addr, record);

                                if (record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelName)
                                {
                                    IntPtr myPtr = IntPtr.Add(addr, 16);
                                    Marshal.PtrToStructure(myPtr, record.TopLevelName);
                                    TopLevelName TLN = new TopLevelName(record.Flags, record.TopLevelName, record.Time);
                                    tmpTLNs.Add(TLN);
                                }
                                else if (record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelNameEx)
                                {
                                    // get the excluded TLN and put it in our collection
                                    IntPtr myPtr = IntPtr.Add(addr, 16);
                                    Marshal.PtrToStructure(myPtr, record.TopLevelName);
                                    string excludedName = Marshal.PtrToStringUni(record.TopLevelName.Buffer, record.TopLevelName.Length / 2);
                                    tmpExcludedTLNs.Add(excludedName);
                                    tmpExcludedNameTime.Add(excludedName, record.Time);
                                }
                                else if (record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustDomainInfo)
                                {
                                    ForestTrustDomainInformation dom = new ForestTrustDomainInformation(record.Flags, record.DomainInfo, record.Time);
                                    tmpDomainInformation.Add(dom);
                                }
                                else if (record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustRecordTypeLast)
                                {
                                    // enumeration is done, but we might still have some unrecognized entries after that
                                    continue;
                                }
                                else
                                {
                                    int    length    = record.Data.Length;
                                    byte[] byteArray = new byte[length];
                                    if ((record.Data.Buffer != (IntPtr)0) && (length != 0))
                                    {
                                        Marshal.Copy(record.Data.Buffer, byteArray, 0, length);
                                    }
                                    tmpBinaryData.Add(byteArray);
                                    tmpBinaryDataTime.Add(record.Time);
                                }
                            }
                        }
                    }
                    finally
                    {
                        UnsafeNativeMethods.LsaFreeMemory(forestTrustInfo);
                    }

                    _topLevelNames = tmpTLNs;
                    _excludedNames = tmpExcludedTLNs;
                    _domainInfo    = tmpDomainInformation;

                    _binaryData       = tmpBinaryData;
                    _excludedNameTime = tmpExcludedNameTime;
                    _binaryDataTime   = tmpBinaryDataTime;

                    // mark it as retrieved
                    retrieved = true;
                }
                finally
                {
                    if (impersonated)
                    {
                        Utils.Revert();
                    }

                    if (targetPtr != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(targetPtr);
                    }
                }
            }
            catch { throw; }
        }
예제 #22
0
		public void CopyTo (TopLevelName[] names, int index)
		{
			throw new NotImplementedException ();
		}
예제 #23
0
        public void Save()
        {
            int                count        = 0;
            IntPtr             records      = (IntPtr)0;
            int                currentCount = 0;
            IntPtr             tmpPtr       = (IntPtr)0;
            IntPtr             forestInfo   = (IntPtr)0;
            PolicySafeHandle   handle       = null;
            LSA_UNICODE_STRING trustedDomainName;
            IntPtr             collisionInfo = (IntPtr)0;
            ArrayList          ptrList       = new ArrayList();
            ArrayList          sidList       = new ArrayList();
            bool               impersonated  = false;
            IntPtr             target        = (IntPtr)0;
            string             serverName    = null;
            IntPtr             fileTime      = (IntPtr)0;

            // first get the count of all the records
            int toplevelNamesCount = TopLevelNames.Count;
            int excludedNamesCount = ExcludedTopLevelNames.Count;
            int trustedDomainCount = TrustedDomainInformation.Count;
            int binaryDataCount    = 0;

            checked
            {
                count += toplevelNamesCount;
                count += excludedNamesCount;
                count += trustedDomainCount;
                if (_binaryData.Count != 0)
                {
                    binaryDataCount = _binaryData.Count;
                    // for the ForestTrustRecordTypeLast record
                    count++;
                    count += binaryDataCount;
                }

                // allocate the memory for all the records
                records = Marshal.AllocHGlobal(count * Marshal.SizeOf(typeof(IntPtr)));
            }

            try
            {
                try
                {
                    IntPtr ptr = (IntPtr)0;
                    fileTime = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(FileTime)));
                    UnsafeNativeMethods.GetSystemTimeAsFileTime(fileTime);

                    // set the time
                    FileTime currentTime = new FileTime();
                    Marshal.PtrToStructure(fileTime, currentTime);

                    for (int i = 0; i < toplevelNamesCount; i++)
                    {
                        // now begin to construct top leve name record
                        LSA_FOREST_TRUST_RECORD record = new LSA_FOREST_TRUST_RECORD();
                        record.Flags           = (int)_topLevelNames[i].Status;
                        record.ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelName;
                        TopLevelName TLN = _topLevelNames[i];
                        record.Time         = TLN.time;
                        record.TopLevelName = new LSA_UNICODE_STRING();
                        ptr = Marshal.StringToHGlobalUni(TLN.Name);
                        ptrList.Add(ptr);
                        UnsafeNativeMethods.RtlInitUnicodeString(record.TopLevelName, ptr);

                        tmpPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        ptrList.Add(tmpPtr);
                        Marshal.StructureToPtr(record, tmpPtr, false);

                        Marshal.WriteIntPtr(records, Marshal.SizeOf(typeof(IntPtr)) * currentCount, tmpPtr);

                        currentCount++;
                    }

                    for (int i = 0; i < excludedNamesCount; i++)
                    {
                        // now begin to construct excluded top leve name record
                        LSA_FOREST_TRUST_RECORD record = new LSA_FOREST_TRUST_RECORD();
                        record.Flags           = 0;
                        record.ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelNameEx;
                        if (_excludedNameTime.Contains(_excludedNames[i]))
                        {
                            record.Time = (LARGE_INTEGER)_excludedNameTime[i];
                        }
                        else
                        {
                            record.Time          = new LARGE_INTEGER();
                            record.Time.lowPart  = currentTime.lower;
                            record.Time.highPart = currentTime.higher;
                        }
                        record.TopLevelName = new LSA_UNICODE_STRING();
                        ptr = Marshal.StringToHGlobalUni(_excludedNames[i]);
                        ptrList.Add(ptr);
                        UnsafeNativeMethods.RtlInitUnicodeString(record.TopLevelName, ptr);
                        tmpPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        ptrList.Add(tmpPtr);
                        Marshal.StructureToPtr(record, tmpPtr, false);

                        Marshal.WriteIntPtr(records, Marshal.SizeOf(typeof(IntPtr)) * currentCount, tmpPtr);

                        currentCount++;
                    }

                    for (int i = 0; i < trustedDomainCount; i++)
                    {
                        // now begin to construct domain info record
                        LSA_FOREST_TRUST_RECORD record = new LSA_FOREST_TRUST_RECORD();
                        record.Flags           = (int)_domainInfo[i].Status;
                        record.ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustDomainInfo;
                        ForestTrustDomainInformation tmp = _domainInfo[i];
                        record.Time = tmp.time;
                        IntPtr pSid      = (IntPtr)0;
                        IntPtr stringSid = (IntPtr)0;
                        stringSid = Marshal.StringToHGlobalUni(tmp.DomainSid);
                        ptrList.Add(stringSid);
                        int result = UnsafeNativeMethods.ConvertStringSidToSidW(stringSid, ref pSid);
                        if (result == 0)
                        {
                            throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
                        }
                        record.DomainInfo     = new LSA_FOREST_TRUST_DOMAIN_INFO();
                        record.DomainInfo.sid = pSid;
                        sidList.Add(pSid);
                        record.DomainInfo.DNSNameBuffer = Marshal.StringToHGlobalUni(tmp.DnsName);
                        ptrList.Add(record.DomainInfo.DNSNameBuffer);
                        record.DomainInfo.DNSNameLength        = (short)(tmp.DnsName == null ? 0 : tmp.DnsName.Length * 2);      // sizeof(WCHAR)
                        record.DomainInfo.DNSNameMaximumLength = (short)(tmp.DnsName == null ? 0 : tmp.DnsName.Length * 2);
                        record.DomainInfo.NetBIOSNameBuffer    = Marshal.StringToHGlobalUni(tmp.NetBiosName);
                        ptrList.Add(record.DomainInfo.NetBIOSNameBuffer);
                        record.DomainInfo.NetBIOSNameLength        = (short)(tmp.NetBiosName == null ? 0 : tmp.NetBiosName.Length * 2);
                        record.DomainInfo.NetBIOSNameMaximumLength = (short)(tmp.NetBiosName == null ? 0 : tmp.NetBiosName.Length * 2);
                        tmpPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        ptrList.Add(tmpPtr);
                        Marshal.StructureToPtr(record, tmpPtr, false);

                        Marshal.WriteIntPtr(records, Marshal.SizeOf(typeof(IntPtr)) * currentCount, tmpPtr);

                        currentCount++;
                    }

                    if (binaryDataCount > 0)
                    {
                        // now begin to construct ForestTrustRecordTypeLast
                        LSA_FOREST_TRUST_RECORD lastRecord = new LSA_FOREST_TRUST_RECORD();
                        lastRecord.Flags           = 0;
                        lastRecord.ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustRecordTypeLast;
                        tmpPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        ptrList.Add(tmpPtr);
                        Marshal.StructureToPtr(lastRecord, tmpPtr, false);
                        Marshal.WriteIntPtr(records, Marshal.SizeOf(typeof(IntPtr)) * currentCount, tmpPtr);
                        currentCount++;

                        for (int i = 0; i < binaryDataCount; i++)
                        {
                            // now begin to construct excluded top leve name record
                            LSA_FOREST_TRUST_RECORD record = new LSA_FOREST_TRUST_RECORD();
                            record.Flags       = 0;
                            record.Time        = (LARGE_INTEGER)_binaryDataTime[i];
                            record.Data.Length = ((byte[])_binaryData[i]).Length;
                            if (record.Data.Length == 0)
                            {
                                record.Data.Buffer = (IntPtr)0;
                            }
                            else
                            {
                                record.Data.Buffer = Marshal.AllocHGlobal(record.Data.Length);
                                ptrList.Add(record.Data.Buffer);
                                Marshal.Copy((byte[])_binaryData[i], 0, record.Data.Buffer, record.Data.Length);
                            }
                            tmpPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                            ptrList.Add(tmpPtr);
                            Marshal.StructureToPtr(record, tmpPtr, false);

                            Marshal.WriteIntPtr(records, Marshal.SizeOf(typeof(IntPtr)) * currentCount, tmpPtr);

                            currentCount++;
                        }
                    }

                    // finally construct the LSA_FOREST_TRUST_INFORMATION
                    LSA_FOREST_TRUST_INFORMATION trustInformation = new LSA_FOREST_TRUST_INFORMATION();
                    trustInformation.RecordCount = count;
                    trustInformation.Entries     = records;
                    forestInfo = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_INFORMATION)));
                    Marshal.StructureToPtr(trustInformation, forestInfo, false);

                    // get policy server name
                    serverName = Utils.GetPolicyServerName(context, true, true, SourceName);

                    // do impersonation first
                    impersonated = Utils.Impersonate(context);

                    // get the policy handle
                    handle = new PolicySafeHandle(Utils.GetPolicyHandle(serverName));

                    // get the target name
                    trustedDomainName = new LSA_UNICODE_STRING();
                    target            = Marshal.StringToHGlobalUni(TargetName);
                    UnsafeNativeMethods.RtlInitUnicodeString(trustedDomainName, target);

                    // call the unmanaged function
                    int error = UnsafeNativeMethods.LsaSetForestTrustInformation(handle, trustedDomainName, forestInfo, 1, out collisionInfo);
                    if (error != 0)
                    {
                        throw ExceptionHelper.GetExceptionFromErrorCode(UnsafeNativeMethods.LsaNtStatusToWinError(error), serverName);
                    }

                    // there is collision, throw proper exception so user can deal with it
                    if (collisionInfo != (IntPtr)0)
                    {
                        throw ExceptionHelper.CreateForestTrustCollisionException(collisionInfo);
                    }

                    // commit the changes
                    error = UnsafeNativeMethods.LsaSetForestTrustInformation(handle, trustedDomainName, forestInfo, 0, out collisionInfo);
                    if (error != 0)
                    {
                        throw ExceptionHelper.GetExceptionFromErrorCode(error, serverName);
                    }

                    // now next time property is invoked, we need to go to the server
                    retrieved = false;
                }
                finally
                {
                    if (impersonated)
                    {
                        Utils.Revert();
                    }

                    // release the memory
                    for (int i = 0; i < ptrList.Count; i++)
                    {
                        Marshal.FreeHGlobal((IntPtr)ptrList[i]);
                    }

                    for (int i = 0; i < sidList.Count; i++)
                    {
                        UnsafeNativeMethods.LocalFree((IntPtr)sidList[i]);
                    }

                    if (records != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(records);
                    }

                    if (forestInfo != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(forestInfo);
                    }

                    if (collisionInfo != (IntPtr)0)
                    {
                        UnsafeNativeMethods.LsaFreeMemory(collisionInfo);
                    }

                    if (target != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(target);
                    }

                    if (fileTime != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(fileTime);
                    }
                }
            }
            catch { throw; }
        }
예제 #24
0
        private void GetForestTrustInfoHelper()
        {
            IntPtr             zero   = IntPtr.Zero;
            PolicySafeHandle   handle = null;
            LSA_UNICODE_STRING result = null;
            bool   flag       = false;
            IntPtr s          = IntPtr.Zero;
            string serverName = null;
            TopLevelNameCollection          names   = new TopLevelNameCollection();
            StringCollection                strings = new StringCollection();
            ForestTrustDomainInfoCollection infos   = new ForestTrustDomainInfoCollection();
            ArrayList list      = new ArrayList();
            Hashtable hashtable = new Hashtable();
            ArrayList list2     = new ArrayList();

            try
            {
                try
                {
                    result = new LSA_UNICODE_STRING();
                    s      = Marshal.StringToHGlobalUni(base.TargetName);
                    System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.RtlInitUnicodeString(result, s);
                    serverName = Utils.GetPolicyServerName(base.context, true, false, base.source);
                    flag       = Utils.Impersonate(base.context);
                    handle     = new PolicySafeHandle(Utils.GetPolicyHandle(serverName));
                    int status = System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LsaQueryForestTrustInformation(handle, result, ref zero);
                    if (status != 0)
                    {
                        int errorCode = System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LsaNtStatusToWinError(status);
                        if (errorCode != 0)
                        {
                            throw ExceptionHelper.GetExceptionFromErrorCode(errorCode, serverName);
                        }
                    }
                    try
                    {
                        if (zero != IntPtr.Zero)
                        {
                            LSA_FOREST_TRUST_INFORMATION structure = new LSA_FOREST_TRUST_INFORMATION();
                            Marshal.PtrToStructure(zero, structure);
                            int    recordCount = structure.RecordCount;
                            IntPtr ptr         = IntPtr.Zero;
                            for (int i = 0; i < recordCount; i++)
                            {
                                ptr = Marshal.ReadIntPtr(structure.Entries, i * Marshal.SizeOf(typeof(IntPtr)));
                                LSA_FOREST_TRUST_RECORD lsa_forest_trust_record = new LSA_FOREST_TRUST_RECORD();
                                Marshal.PtrToStructure(ptr, lsa_forest_trust_record);
                                if (lsa_forest_trust_record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelName)
                                {
                                    IntPtr ptr4 = (IntPtr)(((long)ptr) + 0x10L);
                                    Marshal.PtrToStructure(ptr4, lsa_forest_trust_record.TopLevelName);
                                    TopLevelName name = new TopLevelName(lsa_forest_trust_record.Flags, lsa_forest_trust_record.TopLevelName, lsa_forest_trust_record.Time);
                                    names.Add(name);
                                }
                                else if (lsa_forest_trust_record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelNameEx)
                                {
                                    IntPtr ptr5 = (IntPtr)(((long)ptr) + 0x10L);
                                    Marshal.PtrToStructure(ptr5, lsa_forest_trust_record.TopLevelName);
                                    string str2 = Marshal.PtrToStringUni(lsa_forest_trust_record.TopLevelName.Buffer, lsa_forest_trust_record.TopLevelName.Length / 2);
                                    strings.Add(str2);
                                    hashtable.Add(str2, lsa_forest_trust_record.Time);
                                }
                                else if (lsa_forest_trust_record.ForestTrustType == LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustDomainInfo)
                                {
                                    ForestTrustDomainInformation info = new ForestTrustDomainInformation(lsa_forest_trust_record.Flags, lsa_forest_trust_record.DomainInfo, lsa_forest_trust_record.Time);
                                    infos.Add(info);
                                }
                                else if (lsa_forest_trust_record.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustRecordTypeLast)
                                {
                                    int    length      = lsa_forest_trust_record.Data.Length;
                                    byte[] destination = new byte[length];
                                    if ((lsa_forest_trust_record.Data.Buffer != IntPtr.Zero) && (length != 0))
                                    {
                                        Marshal.Copy(lsa_forest_trust_record.Data.Buffer, destination, 0, length);
                                    }
                                    list.Add(destination);
                                    list2.Add(lsa_forest_trust_record.Time);
                                }
                            }
                        }
                    }
                    finally
                    {
                        System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LsaFreeMemory(zero);
                    }
                    this.topLevelNames    = names;
                    this.excludedNames    = strings;
                    this.domainInfo       = infos;
                    this.binaryData       = list;
                    this.excludedNameTime = hashtable;
                    this.binaryDataTime   = list2;
                    this.retrieved        = true;
                }
                finally
                {
                    if (flag)
                    {
                        Utils.Revert();
                    }
                    if (s != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(s);
                    }
                }
            }
            catch
            {
                throw;
            }
        }
예제 #25
0
        private void GetForestTrustInfoHelper()
        {
            IntPtr intPtr     = (IntPtr)0;
            bool   flag       = false;
            IntPtr hGlobalUni = (IntPtr)0;
            TopLevelNameCollection          topLevelNameCollection          = new TopLevelNameCollection();
            StringCollection                stringCollections               = new StringCollection();
            ForestTrustDomainInfoCollection forestTrustDomainInfoCollection = new ForestTrustDomainInfoCollection();
            ArrayList arrayLists  = new ArrayList();
            Hashtable hashtables  = new Hashtable();
            ArrayList arrayLists1 = new ArrayList();

            try
            {
                try
                {
                    LSA_UNICODE_STRING lSAUNICODESTRING = new LSA_UNICODE_STRING();
                    hGlobalUni = Marshal.StringToHGlobalUni(base.TargetName);
                    UnsafeNativeMethods.RtlInitUnicodeString(lSAUNICODESTRING, hGlobalUni);
                    string policyServerName = Utils.GetPolicyServerName(this.context, true, false, this.source);
                    flag = Utils.Impersonate(this.context);
                    PolicySafeHandle policySafeHandle = new PolicySafeHandle(Utils.GetPolicyHandle(policyServerName));
                    int num = UnsafeNativeMethods.LsaQueryForestTrustInformation(policySafeHandle, lSAUNICODESTRING, ref intPtr);
                    if (num != 0)
                    {
                        int winError = UnsafeNativeMethods.LsaNtStatusToWinError(num);
                        if (winError != 0)
                        {
                            throw ExceptionHelper.GetExceptionFromErrorCode(winError, policyServerName);
                        }
                    }
                    try
                    {
                        if (intPtr != (IntPtr)0)
                        {
                            LSA_FOREST_TRUST_INFORMATION lSAFORESTTRUSTINFORMATION = new LSA_FOREST_TRUST_INFORMATION();
                            Marshal.PtrToStructure(intPtr, lSAFORESTTRUSTINFORMATION);
                            int recordCount = lSAFORESTTRUSTINFORMATION.RecordCount;
                            for (int i = 0; i < recordCount; i++)
                            {
                                IntPtr intPtr1 = Marshal.ReadIntPtr(lSAFORESTTRUSTINFORMATION.Entries, i * Marshal.SizeOf(typeof(IntPtr)));
                                LSA_FOREST_TRUST_RECORD lSAFORESTTRUSTRECORD = new LSA_FOREST_TRUST_RECORD();
                                Marshal.PtrToStructure(intPtr1, lSAFORESTTRUSTRECORD);
                                if (lSAFORESTTRUSTRECORD.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelName)
                                {
                                    if (lSAFORESTTRUSTRECORD.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelNameEx)
                                    {
                                        if (lSAFORESTTRUSTRECORD.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustDomainInfo)
                                        {
                                            if (lSAFORESTTRUSTRECORD.ForestTrustType != LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustRecordTypeLast)
                                            {
                                                int    length   = lSAFORESTTRUSTRECORD.Data.Length;
                                                byte[] numArray = new byte[length];
                                                if (lSAFORESTTRUSTRECORD.Data.Buffer != (IntPtr)0 && length != 0)
                                                {
                                                    Marshal.Copy(lSAFORESTTRUSTRECORD.Data.Buffer, numArray, 0, length);
                                                }
                                                arrayLists.Add(numArray);
                                                arrayLists1.Add(lSAFORESTTRUSTRECORD.Time);
                                            }
                                        }
                                        else
                                        {
                                            ForestTrustDomainInformation forestTrustDomainInformation = new ForestTrustDomainInformation(lSAFORESTTRUSTRECORD.Flags, lSAFORESTTRUSTRECORD.DomainInfo, lSAFORESTTRUSTRECORD.Time);
                                            forestTrustDomainInfoCollection.Add(forestTrustDomainInformation);
                                        }
                                    }
                                    else
                                    {
                                        IntPtr intPtr2 = (IntPtr)((long)intPtr1 + (long)16);
                                        Marshal.PtrToStructure(intPtr2, lSAFORESTTRUSTRECORD.TopLevelName);
                                        string stringUni = Marshal.PtrToStringUni(lSAFORESTTRUSTRECORD.TopLevelName.Buffer, lSAFORESTTRUSTRECORD.TopLevelName.Length / 2);
                                        stringCollections.Add(stringUni);
                                        hashtables.Add(stringUni, lSAFORESTTRUSTRECORD.Time);
                                    }
                                }
                                else
                                {
                                    IntPtr intPtr3 = (IntPtr)((long)intPtr1 + (long)16);
                                    Marshal.PtrToStructure(intPtr3, lSAFORESTTRUSTRECORD.TopLevelName);
                                    TopLevelName topLevelName = new TopLevelName(lSAFORESTTRUSTRECORD.Flags, lSAFORESTTRUSTRECORD.TopLevelName, lSAFORESTTRUSTRECORD.Time);
                                    topLevelNameCollection.Add(topLevelName);
                                }
                            }
                        }
                    }
                    finally
                    {
                        UnsafeNativeMethods.LsaFreeMemory(intPtr);
                    }
                    this.topLevelNames    = topLevelNameCollection;
                    this.excludedNames    = stringCollections;
                    this.domainInfo       = forestTrustDomainInfoCollection;
                    this.binaryData       = arrayLists;
                    this.excludedNameTime = hashtables;
                    this.binaryDataTime   = arrayLists1;
                    this.retrieved        = true;
                }
                finally
                {
                    if (flag)
                    {
                        Utils.Revert();
                    }
                    if (hGlobalUni != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(hGlobalUni);
                    }
                }
            }
            catch
            {
                throw;
            }
        }
    public bool Contains(TopLevelName name)
    {
      Contract.Requires(name != null);

      return default(bool);
    }
예제 #27
0
        public void Save()
        {
            IntPtr    intPtr;
            IntPtr    hGlobalUni;
            object    length;
            object    obj;
            object    length1;
            object    obj1;
            int       count       = 0;
            int       num         = 0;
            IntPtr    intPtr1     = (IntPtr)0;
            IntPtr    intPtr2     = (IntPtr)0;
            ArrayList arrayLists  = new ArrayList();
            ArrayList arrayLists1 = new ArrayList();
            bool      flag        = false;
            IntPtr    hGlobalUni1 = (IntPtr)0;
            IntPtr    intPtr3     = (IntPtr)0;

            count = count + this.TopLevelNames.Count;
            count = count + this.ExcludedTopLevelNames.Count;
            count = count + this.TrustedDomainInformation.Count;
            if (this.binaryData.Count != 0)
            {
                count++;
                count = count + this.binaryData.Count;
            }
            IntPtr intPtr4 = Marshal.AllocHGlobal(count * Marshal.SizeOf(typeof(IntPtr)));

            try
            {
                try
                {
                    intPtr3 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(FileTime)));
                    UnsafeNativeMethods.GetSystemTimeAsFileTime(intPtr3);
                    FileTime fileTime = new FileTime();
                    Marshal.PtrToStructure(intPtr3, fileTime);
                    for (int i = 0; i < this.topLevelNames.Count; i++)
                    {
                        LSA_FOREST_TRUST_RECORD lSAFORESTTRUSTRECORD = new LSA_FOREST_TRUST_RECORD();
                        lSAFORESTTRUSTRECORD.Flags           = (int)this.topLevelNames[i].Status;
                        lSAFORESTTRUSTRECORD.ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelName;
                        TopLevelName item = this.topLevelNames[i];
                        lSAFORESTTRUSTRECORD.Time         = item.time;
                        lSAFORESTTRUSTRECORD.TopLevelName = new LSA_UNICODE_STRING();
                        hGlobalUni = Marshal.StringToHGlobalUni(item.Name);
                        arrayLists.Add(hGlobalUni);
                        UnsafeNativeMethods.RtlInitUnicodeString(lSAFORESTTRUSTRECORD.TopLevelName, hGlobalUni);
                        intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        arrayLists.Add(intPtr);
                        Marshal.StructureToPtr(lSAFORESTTRUSTRECORD, intPtr, false);
                        Marshal.WriteIntPtr(intPtr4, Marshal.SizeOf(typeof(IntPtr)) * num, intPtr);
                        num++;
                    }
                    for (int j = 0; j < this.excludedNames.Count; j++)
                    {
                        LSA_FOREST_TRUST_RECORD lARGEINTEGER = new LSA_FOREST_TRUST_RECORD();
                        lARGEINTEGER.Flags           = 0;
                        lARGEINTEGER.ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelNameEx;
                        if (!this.excludedNameTime.Contains(this.excludedNames[j]))
                        {
                            lARGEINTEGER.Time          = new LARGE_INTEGER();
                            lARGEINTEGER.Time.lowPart  = fileTime.lower;
                            lARGEINTEGER.Time.highPart = fileTime.higher;
                        }
                        else
                        {
                            lARGEINTEGER.Time = (LARGE_INTEGER)this.excludedNameTime[(object)j];
                        }
                        lARGEINTEGER.TopLevelName = new LSA_UNICODE_STRING();
                        hGlobalUni = Marshal.StringToHGlobalUni(this.excludedNames[j]);
                        arrayLists.Add(hGlobalUni);
                        UnsafeNativeMethods.RtlInitUnicodeString(lARGEINTEGER.TopLevelName, hGlobalUni);
                        intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        arrayLists.Add(intPtr);
                        Marshal.StructureToPtr(lARGEINTEGER, intPtr, false);
                        Marshal.WriteIntPtr(intPtr4, Marshal.SizeOf(typeof(IntPtr)) * num, intPtr);
                        num++;
                    }
                    int num1 = 0;
                    while (num1 < this.domainInfo.Count)
                    {
                        LSA_FOREST_TRUST_RECORD status = new LSA_FOREST_TRUST_RECORD();
                        status.Flags           = (int)this.domainInfo[num1].Status;
                        status.ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustDomainInfo;
                        ForestTrustDomainInformation forestTrustDomainInformation = this.domainInfo[num1];
                        status.Time = forestTrustDomainInformation.time;
                        IntPtr intPtr5     = (IntPtr)0;
                        IntPtr hGlobalUni2 = Marshal.StringToHGlobalUni(forestTrustDomainInformation.DomainSid);
                        arrayLists.Add(hGlobalUni2);
                        int sidW = UnsafeNativeMethods.ConvertStringSidToSidW(hGlobalUni2, ref intPtr5);
                        if (sidW != 0)
                        {
                            status.DomainInfo     = new LSA_FOREST_TRUST_DOMAIN_INFO();
                            status.DomainInfo.sid = intPtr5;
                            arrayLists1.Add(intPtr5);
                            status.DomainInfo.DNSNameBuffer = Marshal.StringToHGlobalUni(forestTrustDomainInformation.DnsName);
                            arrayLists.Add(status.DomainInfo.DNSNameBuffer);
                            LSA_FOREST_TRUST_DOMAIN_INFO domainInfo = status.DomainInfo;
                            if (forestTrustDomainInformation.DnsName == null)
                            {
                                length = null;
                            }
                            else
                            {
                                length = forestTrustDomainInformation.DnsName.Length * 2;
                            }
                            domainInfo.DNSNameLength = (short)length;
                            LSA_FOREST_TRUST_DOMAIN_INFO lSAFORESTTRUSTDOMAININFO = status.DomainInfo;
                            if (forestTrustDomainInformation.DnsName == null)
                            {
                                obj = null;
                            }
                            else
                            {
                                obj = forestTrustDomainInformation.DnsName.Length * 2;
                            }
                            lSAFORESTTRUSTDOMAININFO.DNSNameMaximumLength = (short)obj;
                            status.DomainInfo.NetBIOSNameBuffer           = Marshal.StringToHGlobalUni(forestTrustDomainInformation.NetBiosName);
                            arrayLists.Add(status.DomainInfo.NetBIOSNameBuffer);
                            LSA_FOREST_TRUST_DOMAIN_INFO domainInfo1 = status.DomainInfo;
                            if (forestTrustDomainInformation.NetBiosName == null)
                            {
                                length1 = null;
                            }
                            else
                            {
                                length1 = forestTrustDomainInformation.NetBiosName.Length * 2;
                            }
                            domainInfo1.NetBIOSNameLength = (short)length1;
                            LSA_FOREST_TRUST_DOMAIN_INFO lSAFORESTTRUSTDOMAININFO1 = status.DomainInfo;
                            if (forestTrustDomainInformation.NetBiosName == null)
                            {
                                obj1 = null;
                            }
                            else
                            {
                                obj1 = forestTrustDomainInformation.NetBiosName.Length * 2;
                            }
                            lSAFORESTTRUSTDOMAININFO1.NetBIOSNameMaximumLength = (short)obj1;
                            intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                            arrayLists.Add(intPtr);
                            Marshal.StructureToPtr(status, intPtr, false);
                            Marshal.WriteIntPtr(intPtr4, Marshal.SizeOf(typeof(IntPtr)) * num, intPtr);
                            num++;
                            num1++;
                        }
                        else
                        {
                            throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
                        }
                    }
                    if (this.binaryData.Count > 0)
                    {
                        LSA_FOREST_TRUST_RECORD lSAFORESTTRUSTRECORD1 = new LSA_FOREST_TRUST_RECORD();
                        lSAFORESTTRUSTRECORD1.Flags           = 0;
                        lSAFORESTTRUSTRECORD1.ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustRecordTypeLast;
                        intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        arrayLists.Add(intPtr);
                        Marshal.StructureToPtr(lSAFORESTTRUSTRECORD1, intPtr, false);
                        Marshal.WriteIntPtr(intPtr4, Marshal.SizeOf(typeof(IntPtr)) * num, intPtr);
                        num++;
                        for (int k = 0; k < this.binaryData.Count; k++)
                        {
                            LSA_FOREST_TRUST_RECORD item1 = new LSA_FOREST_TRUST_RECORD();
                            item1.Flags       = 0;
                            item1.Time        = (LARGE_INTEGER)this.binaryDataTime[k];
                            item1.Data.Length = (int)((byte[])this.binaryData[k]).Length;
                            if (item1.Data.Length != 0)
                            {
                                item1.Data.Buffer = Marshal.AllocHGlobal(item1.Data.Length);
                                arrayLists.Add(item1.Data.Buffer);
                                Marshal.Copy((byte[])this.binaryData[k], 0, item1.Data.Buffer, item1.Data.Length);
                            }
                            else
                            {
                                item1.Data.Buffer = (IntPtr)0;
                            }
                            intPtr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                            arrayLists.Add(intPtr);
                            Marshal.StructureToPtr(item1, intPtr, false);
                            Marshal.WriteIntPtr(intPtr4, Marshal.SizeOf(typeof(IntPtr)) * num, intPtr);
                            num++;
                        }
                    }
                    LSA_FOREST_TRUST_INFORMATION lSAFORESTTRUSTINFORMATION = new LSA_FOREST_TRUST_INFORMATION();
                    lSAFORESTTRUSTINFORMATION.RecordCount = count;
                    lSAFORESTTRUSTINFORMATION.Entries     = intPtr4;
                    intPtr1 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_INFORMATION)));
                    Marshal.StructureToPtr(lSAFORESTTRUSTINFORMATION, intPtr1, false);
                    string policyServerName = Utils.GetPolicyServerName(this.context, true, true, base.SourceName);
                    flag = Utils.Impersonate(this.context);
                    PolicySafeHandle   policySafeHandle = new PolicySafeHandle(Utils.GetPolicyHandle(policyServerName));
                    LSA_UNICODE_STRING lSAUNICODESTRING = new LSA_UNICODE_STRING();
                    hGlobalUni1 = Marshal.StringToHGlobalUni(base.TargetName);
                    UnsafeNativeMethods.RtlInitUnicodeString(lSAUNICODESTRING, hGlobalUni1);
                    int num2 = UnsafeNativeMethods.LsaSetForestTrustInformation(policySafeHandle, lSAUNICODESTRING, intPtr1, 1, out intPtr2);
                    if (num2 == 0)
                    {
                        if (intPtr2 == (IntPtr)0)
                        {
                            num2 = UnsafeNativeMethods.LsaSetForestTrustInformation(policySafeHandle, lSAUNICODESTRING, intPtr1, 0, out intPtr2);
                            if (num2 == 0)
                            {
                                this.retrieved = false;
                            }
                            else
                            {
                                throw ExceptionHelper.GetExceptionFromErrorCode(num2, policyServerName);
                            }
                        }
                        else
                        {
                            throw ExceptionHelper.CreateForestTrustCollisionException(intPtr2);
                        }
                    }
                    else
                    {
                        throw ExceptionHelper.GetExceptionFromErrorCode(UnsafeNativeMethods.LsaNtStatusToWinError(num2), policyServerName);
                    }
                }
                finally
                {
                    if (flag)
                    {
                        Utils.Revert();
                    }
                    for (int l = 0; l < arrayLists.Count; l++)
                    {
                        Marshal.FreeHGlobal((IntPtr)arrayLists[l]);
                    }
                    for (int m = 0; m < arrayLists1.Count; m++)
                    {
                        UnsafeNativeMethods.LocalFree((IntPtr)arrayLists1[m]);
                    }
                    if (intPtr4 != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(intPtr4);
                    }
                    if (intPtr1 != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(intPtr1);
                    }
                    if (intPtr2 != (IntPtr)0)
                    {
                        UnsafeNativeMethods.LsaFreeMemory(intPtr2);
                    }
                    if (hGlobalUni1 != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(hGlobalUni1);
                    }
                    if (intPtr3 != (IntPtr)0)
                    {
                        Marshal.FreeHGlobal(intPtr3);
                    }
                }
            }
            catch
            {
                throw;
            }
        }
예제 #28
0
        public void Save()
        {
            int              num           = 0;
            IntPtr           zero          = IntPtr.Zero;
            int              num2          = 0;
            IntPtr           ptr2          = IntPtr.Zero;
            IntPtr           ptr           = IntPtr.Zero;
            PolicySafeHandle handle        = null;
            IntPtr           collisionInfo = IntPtr.Zero;
            ArrayList        list          = new ArrayList();
            ArrayList        list2         = new ArrayList();
            bool             flag          = false;
            IntPtr           s             = IntPtr.Zero;
            string           serverName    = null;
            IntPtr           fileTime      = IntPtr.Zero;
            int              count         = this.TopLevelNames.Count;
            int              num4          = this.ExcludedTopLevelNames.Count;
            int              num5          = this.TrustedDomainInformation.Count;
            int              num6          = 0;

            num += count;
            num += num4;
            num += num5;
            if (this.binaryData.Count != 0)
            {
                num6 = this.binaryData.Count;
                num++;
                num += num6;
            }
            zero = Marshal.AllocHGlobal((int)(num * Marshal.SizeOf(typeof(IntPtr))));
            try
            {
                try
                {
                    IntPtr ptr7 = IntPtr.Zero;
                    fileTime = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(FileTime)));
                    System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.GetSystemTimeAsFileTime(fileTime);
                    FileTime structure = new FileTime();
                    Marshal.PtrToStructure(fileTime, structure);
                    for (int i = 0; i < count; i++)
                    {
                        LSA_FOREST_TRUST_RECORD lsa_forest_trust_record = new LSA_FOREST_TRUST_RECORD {
                            Flags           = (int)this.topLevelNames[i].Status,
                            ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelName
                        };
                        TopLevelName name = this.topLevelNames[i];
                        lsa_forest_trust_record.Time         = name.time;
                        lsa_forest_trust_record.TopLevelName = new LSA_UNICODE_STRING();
                        ptr7 = Marshal.StringToHGlobalUni(name.Name);
                        list.Add(ptr7);
                        System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.RtlInitUnicodeString(lsa_forest_trust_record.TopLevelName, ptr7);
                        ptr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        list.Add(ptr2);
                        Marshal.StructureToPtr(lsa_forest_trust_record, ptr2, false);
                        Marshal.WriteIntPtr(zero, Marshal.SizeOf(typeof(IntPtr)) * num2, ptr2);
                        num2++;
                    }
                    for (int j = 0; j < num4; j++)
                    {
                        LSA_FOREST_TRUST_RECORD lsa_forest_trust_record2 = new LSA_FOREST_TRUST_RECORD {
                            Flags           = 0,
                            ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustTopLevelNameEx
                        };
                        if (this.excludedNameTime.Contains(this.excludedNames[j]))
                        {
                            lsa_forest_trust_record2.Time = (LARGE_INTEGER)this.excludedNameTime[j];
                        }
                        else
                        {
                            lsa_forest_trust_record2.Time          = new LARGE_INTEGER();
                            lsa_forest_trust_record2.Time.lowPart  = structure.lower;
                            lsa_forest_trust_record2.Time.highPart = structure.higher;
                        }
                        lsa_forest_trust_record2.TopLevelName = new LSA_UNICODE_STRING();
                        ptr7 = Marshal.StringToHGlobalUni(this.excludedNames[j]);
                        list.Add(ptr7);
                        System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.RtlInitUnicodeString(lsa_forest_trust_record2.TopLevelName, ptr7);
                        ptr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        list.Add(ptr2);
                        Marshal.StructureToPtr(lsa_forest_trust_record2, ptr2, false);
                        Marshal.WriteIntPtr(zero, Marshal.SizeOf(typeof(IntPtr)) * num2, ptr2);
                        num2++;
                    }
                    for (int k = 0; k < num5; k++)
                    {
                        LSA_FOREST_TRUST_RECORD lsa_forest_trust_record3 = new LSA_FOREST_TRUST_RECORD {
                            Flags           = (int)this.domainInfo[k].Status,
                            ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustDomainInfo
                        };
                        ForestTrustDomainInformation information = this.domainInfo[k];
                        lsa_forest_trust_record3.Time = information.time;
                        IntPtr pSid = IntPtr.Zero;
                        IntPtr ptr9 = IntPtr.Zero;
                        ptr9 = Marshal.StringToHGlobalUni(information.DomainSid);
                        list.Add(ptr9);
                        if (System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.ConvertStringSidToSidW(ptr9, ref pSid) == 0)
                        {
                            throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
                        }
                        lsa_forest_trust_record3.DomainInfo     = new LSA_FOREST_TRUST_DOMAIN_INFO();
                        lsa_forest_trust_record3.DomainInfo.sid = pSid;
                        list2.Add(pSid);
                        lsa_forest_trust_record3.DomainInfo.DNSNameBuffer = Marshal.StringToHGlobalUni(information.DnsName);
                        list.Add(lsa_forest_trust_record3.DomainInfo.DNSNameBuffer);
                        lsa_forest_trust_record3.DomainInfo.DNSNameLength        = (information.DnsName == null) ? ((short)0) : ((short)(information.DnsName.Length * 2));
                        lsa_forest_trust_record3.DomainInfo.DNSNameMaximumLength = (information.DnsName == null) ? ((short)0) : ((short)(information.DnsName.Length * 2));
                        lsa_forest_trust_record3.DomainInfo.NetBIOSNameBuffer    = Marshal.StringToHGlobalUni(information.NetBiosName);
                        list.Add(lsa_forest_trust_record3.DomainInfo.NetBIOSNameBuffer);
                        lsa_forest_trust_record3.DomainInfo.NetBIOSNameLength        = (information.NetBiosName == null) ? ((short)0) : ((short)(information.NetBiosName.Length * 2));
                        lsa_forest_trust_record3.DomainInfo.NetBIOSNameMaximumLength = (information.NetBiosName == null) ? ((short)0) : ((short)(information.NetBiosName.Length * 2));
                        ptr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        list.Add(ptr2);
                        Marshal.StructureToPtr(lsa_forest_trust_record3, ptr2, false);
                        Marshal.WriteIntPtr(zero, Marshal.SizeOf(typeof(IntPtr)) * num2, ptr2);
                        num2++;
                    }
                    if (num6 > 0)
                    {
                        LSA_FOREST_TRUST_RECORD lsa_forest_trust_record4 = new LSA_FOREST_TRUST_RECORD {
                            Flags           = 0,
                            ForestTrustType = LSA_FOREST_TRUST_RECORD_TYPE.ForestTrustRecordTypeLast
                        };
                        ptr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                        list.Add(ptr2);
                        Marshal.StructureToPtr(lsa_forest_trust_record4, ptr2, false);
                        Marshal.WriteIntPtr(zero, Marshal.SizeOf(typeof(IntPtr)) * num2, ptr2);
                        num2++;
                        for (int m = 0; m < num6; m++)
                        {
                            LSA_FOREST_TRUST_RECORD lsa_forest_trust_record5 = new LSA_FOREST_TRUST_RECORD {
                                Flags = 0,
                                Time  = (LARGE_INTEGER)this.binaryDataTime[m]
                            };
                            lsa_forest_trust_record5.Data.Length = ((byte[])this.binaryData[m]).Length;
                            if (lsa_forest_trust_record5.Data.Length == 0)
                            {
                                lsa_forest_trust_record5.Data.Buffer = IntPtr.Zero;
                            }
                            else
                            {
                                lsa_forest_trust_record5.Data.Buffer = Marshal.AllocHGlobal(lsa_forest_trust_record5.Data.Length);
                                list.Add(lsa_forest_trust_record5.Data.Buffer);
                                Marshal.Copy((byte[])this.binaryData[m], 0, lsa_forest_trust_record5.Data.Buffer, lsa_forest_trust_record5.Data.Length);
                            }
                            ptr2 = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_RECORD)));
                            list.Add(ptr2);
                            Marshal.StructureToPtr(lsa_forest_trust_record5, ptr2, false);
                            Marshal.WriteIntPtr(zero, Marshal.SizeOf(typeof(IntPtr)) * num2, ptr2);
                            num2++;
                        }
                    }
                    LSA_FOREST_TRUST_INFORMATION lsa_forest_trust_information = new LSA_FOREST_TRUST_INFORMATION {
                        RecordCount = num,
                        Entries     = zero
                    };
                    ptr = Marshal.AllocHGlobal(Marshal.SizeOf(typeof(LSA_FOREST_TRUST_INFORMATION)));
                    Marshal.StructureToPtr(lsa_forest_trust_information, ptr, false);
                    serverName = Utils.GetPolicyServerName(base.context, true, true, base.SourceName);
                    flag       = Utils.Impersonate(base.context);
                    handle     = new PolicySafeHandle(Utils.GetPolicyHandle(serverName));
                    LSA_UNICODE_STRING result = new LSA_UNICODE_STRING();
                    s = Marshal.StringToHGlobalUni(base.TargetName);
                    System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.RtlInitUnicodeString(result, s);
                    int status = System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LsaSetForestTrustInformation(handle, result, ptr, 1, out collisionInfo);
                    if (status != 0)
                    {
                        throw ExceptionHelper.GetExceptionFromErrorCode(System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LsaNtStatusToWinError(status), serverName);
                    }
                    if (collisionInfo != IntPtr.Zero)
                    {
                        throw ExceptionHelper.CreateForestTrustCollisionException(collisionInfo);
                    }
                    status = System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LsaSetForestTrustInformation(handle, result, ptr, 0, out collisionInfo);
                    if (status != 0)
                    {
                        throw ExceptionHelper.GetExceptionFromErrorCode(status, serverName);
                    }
                    this.retrieved = false;
                }
                finally
                {
                    if (flag)
                    {
                        Utils.Revert();
                    }
                    for (int n = 0; n < list.Count; n++)
                    {
                        Marshal.FreeHGlobal((IntPtr)list[n]);
                    }
                    for (int num14 = 0; num14 < list2.Count; num14++)
                    {
                        System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LocalFree((IntPtr)list2[num14]);
                    }
                    if (zero != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(zero);
                    }
                    if (ptr != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(ptr);
                    }
                    if (collisionInfo != IntPtr.Zero)
                    {
                        System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LsaFreeMemory(collisionInfo);
                    }
                    if (s != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(s);
                    }
                    if (fileTime != IntPtr.Zero)
                    {
                        Marshal.FreeHGlobal(fileTime);
                    }
                }
            }
            catch
            {
                throw;
            }
        }