internal static string GetDnsDomainName(string domainName)
{
DomainControllerInfo domainControllerInfo;
int errorCode = 0;
//
// Locator.DsGetDcNameWrapper internally passes the ReturnDNSName flag when calling DsGetDcName
//
errorCode = Locator.DsGetDcNameWrapper(null, domainName, null, (long)PrivateLocatorFlags.DirectoryServicesRequired, out domainControllerInfo);
if (errorCode == NativeMethods.ERROR_NO_SUCH_DOMAIN)
{
// try again with force rediscovery
errorCode = Locator.DsGetDcNameWrapper(null, domainName, null, (long)((long)PrivateLocatorFlags.DirectoryServicesRequired | (long)LocatorOptions.ForceRediscovery), out domainControllerInfo);
if (errorCode == NativeMethods.ERROR_NO_SUCH_DOMAIN)
{
return(null);
}
else if (errorCode != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
}
else if (errorCode != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
Debug.Assert(domainControllerInfo != null);
Debug.Assert(domainControllerInfo.DomainName != null);
return(domainControllerInfo.DomainName);
}
private DirectoryServer FindDirectoryServerInternal(string siteName, bool forceRediscovery)
{
DomainControllerInfo info;
LocatorOptions options = 0L;
int errorCode = 0;
if ((siteName != null) && (siteName.Length == 0))
{
throw new ArgumentException(Res.GetString("EmptyStringParameter"), "siteName");
}
if (!this.committed)
{
throw new InvalidOperationException(Res.GetString("CannotPerformOperationOnUncommittedObject"));
}
if (forceRediscovery)
{
options = LocatorOptions.ForceRediscovery;
}
errorCode = Locator.DsGetDcNameWrapper(null, this.dnsName, siteName, options | 0x8000L, out info);
if (errorCode == 0x54b)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ReplicaNotFound"), typeof(DirectoryServer), null);
}
if (errorCode != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
string domainControllerName = info.DomainControllerName.Substring(2);
return(new DomainController(Utils.GetNewDirectoryContext(domainControllerName, DirectoryContextType.DirectoryServer, base.context), domainControllerName));
}
//
// this method is called when the forest name is explicitly specified
// and we want to check if that matches the current logged on forest
//
internal bool isCurrentForest()
{
bool result = false;
Debug.Assert(_name != null);
DomainControllerInfo domainControllerInfo = Locator.GetDomainControllerInfo(null, _name, null, (long)(PrivateLocatorFlags.DirectoryServicesRequired | PrivateLocatorFlags.ReturnDNSName));
DomainControllerInfo currentDomainControllerInfo;
string loggedOnDomain = GetLoggedOnDomain();
int errorCode = Locator.DsGetDcNameWrapper(null, loggedOnDomain, null, (long)(PrivateLocatorFlags.DirectoryServicesRequired | PrivateLocatorFlags.ReturnDNSName), out currentDomainControllerInfo);
if (errorCode == 0)
{
Debug.Assert(domainControllerInfo.DnsForestName != null);
Debug.Assert(currentDomainControllerInfo.DnsForestName != null);
result = (Utils.Compare(domainControllerInfo.DnsForestName, currentDomainControllerInfo.DnsForestName) == 0);
}
//
// if there is no forest associated with the logged on domain, then we return false
//
else if (errorCode != NativeMethods.ERROR_NO_SUCH_DOMAIN)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
return(result);
}
private static void GetLibraryHandle()
{
string systemDirectory = Environment.SystemDirectory;
IntPtr intPtr = UnsafeNativeMethods.LoadLibrary(string.Concat(systemDirectory, "\\ntdsapi.dll"));
if (intPtr != (IntPtr)0)
{
DirectoryContext.ADHandle = new LoadLibrarySafeHandle(intPtr);
DirectoryInfo parent = Directory.GetParent(systemDirectory);
intPtr = UnsafeNativeMethods.LoadLibrary(string.Concat(parent.FullName, "\\ADAM\\ntdsapi.dll"));
if (intPtr != (IntPtr)0)
{
DirectoryContext.ADAMHandle = new LoadLibrarySafeHandle(intPtr);
return;
}
else
{
DirectoryContext.ADAMHandle = DirectoryContext.ADHandle;
return;
}
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
}
private static void GetLibraryHandle()
{
// first get AD handle
string systemPath = Environment.SystemDirectory;
IntPtr tempHandle = UnsafeNativeMethods.LoadLibrary(systemPath + "\\ntdsapi.dll");
if (tempHandle == (IntPtr)0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
else
{
ADHandle = new LoadLibrarySafeHandle(tempHandle);
}
// not get the ADAM handle
// got to the windows\adam directory
DirectoryInfo windowsDirectory = Directory.GetParent(systemPath);
tempHandle = UnsafeNativeMethods.LoadLibrary(windowsDirectory.FullName + "\\ADAM\\ntdsapi.dll");
if (tempHandle == (IntPtr)0)
{
ADAMHandle = ADHandle;
}
else
{
ADAMHandle = new LoadLibrarySafeHandle(tempHandle);
}
}
internal ForestTrustDomainInformation(int flag, LSA_FOREST_TRUST_DOMAIN_INFO domainInfo, LARGE_INTEGER time)
{
this.status = (ForestTrustDomainStatus)flag;
this.dnsName = Marshal.PtrToStringUni(domainInfo.DNSNameBuffer, domainInfo.DNSNameLength / 2);
this.nbName = Marshal.PtrToStringUni(domainInfo.NetBIOSNameBuffer, domainInfo.NetBIOSNameLength / 2);
IntPtr intPtr = (IntPtr)0;
int stringSidW = UnsafeNativeMethods.ConvertSidToStringSidW(domainInfo.sid, ref intPtr);
if (stringSidW != 0)
{
try
{
this.sid = Marshal.PtrToStringUni(intPtr);
}
finally
{
UnsafeNativeMethods.LocalFree(intPtr);
}
this.time = time;
return;
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
}
internal static string GetDnsDomainName(string domainName)
{
DomainControllerInfo domainControllerInfo = null;
int num = Locator.DsGetDcNameWrapper(null, domainName, null, (long)16, out domainControllerInfo);
if (num != 0x54b)
{
if (num != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(num);
}
}
else
{
num = Locator.DsGetDcNameWrapper(null, domainName, null, (long)17, out domainControllerInfo);
if (num != 0x54b)
{
if (num != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(num);
}
}
else
{
return(null);
}
}
return(domainControllerInfo.DomainName);
}
internal static ArrayList EnumerateDomainControllers(DirectoryContext context, string domainName, string siteName, long dcFlags)
{
Hashtable hashtables;
DomainControllerInfo domainControllerInfo = null;
ArrayList arrayLists = new ArrayList();
if (siteName == null)
{
int num = Locator.DsGetDcNameWrapper(null, domainName, null, dcFlags & (long)0x9040, out domainControllerInfo);
if (num != 0)
{
if (num != 0x54b)
{
throw ExceptionHelper.GetExceptionFromErrorCode(num);
}
else
{
return(arrayLists);
}
}
else
{
siteName = domainControllerInfo.ClientSiteName;
}
}
if (!DirectoryContext.DnsgetdcSupported)
{
hashtables = Locator.DnsQueryWrapper(domainName, null, dcFlags);
if (siteName != null)
{
foreach (string key in Locator.DnsQueryWrapper(domainName, siteName, dcFlags).Keys)
{
if (hashtables.Contains(key))
{
continue;
}
hashtables.Add(key, null);
}
}
}
else
{
hashtables = Locator.DnsGetDcWrapper(domainName, siteName, dcFlags);
}
foreach (string str in hashtables.Keys)
{
DirectoryContext newDirectoryContext = Utils.GetNewDirectoryContext(str, DirectoryContextType.DirectoryServer, context);
if ((dcFlags & (long)64) == (long)0)
{
arrayLists.Add(new DomainController(newDirectoryContext, str));
}
else
{
arrayLists.Add(new GlobalCatalog(newDirectoryContext, str));
}
}
return(arrayLists);
}
private static IntPtr GetTrustedDomainInfo(DirectoryContext targetContext, string? targetName, bool isForest)
{
PolicySafeHandle? policyHandle = null;
IntPtr buffer = (IntPtr)0;
bool impersonated = false;
string? serverName = null;
try
{
try
{
serverName = Utils.GetPolicyServerName(targetContext, isForest, false, targetName);
impersonated = Utils.Impersonate(targetContext);
try
{
policyHandle = new PolicySafeHandle(Utils.GetPolicyHandle(serverName));
}
catch (ActiveDirectoryOperationException)
{
if (impersonated)
{
Utils.Revert();
impersonated = false;
}
// try anonymous
Utils.ImpersonateAnonymous();
impersonated = true;
policyHandle = new PolicySafeHandle(Utils.GetPolicyHandle(serverName));
}
catch (UnauthorizedAccessException)
{
if (impersonated)
{
Utils.Revert();
impersonated = false;
}
// try anonymous
Utils.ImpersonateAnonymous();
impersonated = true;
policyHandle = new PolicySafeHandle(Utils.GetPolicyHandle(serverName));
}
int result = UnsafeNativeMethods.LsaQueryInformationPolicy(policyHandle, policyDnsDomainInformation, out buffer);
if (result != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(UnsafeNativeMethods.LsaNtStatusToWinError(result), serverName);
}
return buffer;
}
finally
{
if (impersonated)
Utils.Revert();
}
}
catch { throw; }
}
internal static ArrayList EnumerateDomainControllers(DirectoryContext context, string?domainName, string?siteName, long dcFlags)
{
Hashtable?allDCs = null;
ArrayList dcs = new ArrayList();
//
// this api obtains the list of DCs/GCs based on dns records. The DCs/GCs that have registered
// non site specific records for the domain/forest are returned. Additionally DCs/GCs that have registered site specific records
// (site is either specified or defaulted to the site of the local machine) are also returned in this list.
//
if (siteName == null)
{
//
// if the site name is not specified then we get the site specific records for the local machine's site (in the context of the domain/forest/application partition that is specified)
// (sitename could still be null if the machine is not in any site for the specified domain/forest, in that case we don't look for any site specific records)
//
DomainControllerInfo domainControllerInfo;
int errorCode = DsGetDcNameWrapper(null, domainName, null, dcFlags & (long)(PrivateLocatorFlags.GCRequired | PrivateLocatorFlags.DSWriteableRequired | PrivateLocatorFlags.OnlyLDAPNeeded), out domainControllerInfo);
if (errorCode == 0)
{
siteName = domainControllerInfo.ClientSiteName;
}
else if (errorCode == NativeMethods.ERROR_NO_SUCH_DOMAIN)
{
// return an empty collection
return(dcs);
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
}
// this will get both the non site specific and the site specific records
allDCs = DnsGetDcWrapper(domainName, siteName, dcFlags);
foreach (string dcName in allDCs.Keys)
{
DirectoryContext dcContext = Utils.GetNewDirectoryContext(dcName, DirectoryContextType.DirectoryServer, context);
if ((dcFlags & (long)PrivateLocatorFlags.GCRequired) != 0)
{
// add a GlobalCatalog object
dcs.Add(new GlobalCatalog(dcContext, dcName));
}
else
{
// add a domain controller object
dcs.Add(new DomainController(dcContext, dcName));
}
}
return(dcs);
}
internal void SyncReplicaAllHelper(IntPtr handle, SyncReplicaFromAllServersCallback syncAllFunctionPointer, string partition, SyncFromAllServersOptions option, SyncUpdateCallback callback, LoadLibrarySafeHandle libHandle)
{
IntPtr errorInfo = (IntPtr)0;
if (!Partitions.Contains(partition))
{
throw new ArgumentException(SR.ServerNotAReplica, "partition");
}
// we want to return the dn instead of DNS guid
// call DsReplicaSyncAllW
IntPtr functionPtr = UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaSyncAllW");
if (functionPtr == (IntPtr)0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
UnsafeNativeMethods.DsReplicaSyncAllW dsReplicaSyncAllW = (UnsafeNativeMethods.DsReplicaSyncAllW)Marshal.GetDelegateForFunctionPointer(functionPtr, typeof(UnsafeNativeMethods.DsReplicaSyncAllW));
int result = dsReplicaSyncAllW(handle, partition, (int)option | DS_REPSYNCALL_ID_SERVERS_BY_DN, syncAllFunctionPointer, (IntPtr)0, ref errorInfo);
try
{
// error happens during the synchronization
if (errorInfo != (IntPtr)0)
{
SyncFromAllServersOperationException e = ExceptionHelper.CreateSyncAllException(errorInfo, false);
if (e == null)
{
return;
}
else
{
throw e;
}
}
else
{
// API does not return error infor occurred during synchronization, but result is not success.
if (result != 0)
{
throw new SyncFromAllServersOperationException(ExceptionHelper.GetErrorMessage(result, false));
}
}
}
finally
{
// release the memory
if (errorInfo != (IntPtr)0)
{
UnsafeNativeMethods.LocalFree(errorInfo);
}
}
}
internal static DomainControllerInfo GetDomainControllerInfo(string computerName, string domainName, string siteName, long flags)
{
DomainControllerInfo info;
int errorCode = 0;
errorCode = DsGetDcNameWrapper(computerName, domainName, siteName, flags, out info);
if (errorCode != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode, domainName);
}
return(info);
}
internal static ArrayList EnumerateDomainControllers(DirectoryContext context, string domainName, string siteName, long dcFlags)
{
Hashtable hashtable = null;
ArrayList list = new ArrayList();
if (siteName == null)
{
DomainControllerInfo info;
int errorCode = DsGetDcNameWrapper(null, domainName, null, dcFlags & 0x9040L, out info);
switch (errorCode)
{
case 0:
siteName = info.ClientSiteName;
goto Label_003C;
case 0x54b:
return(list);
}
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
Label_003C:
if (DirectoryContext.DnsgetdcSupported)
{
hashtable = DnsGetDcWrapper(domainName, siteName, dcFlags);
}
else
{
hashtable = DnsQueryWrapper(domainName, null, dcFlags);
if (siteName != null)
{
foreach (string str in DnsQueryWrapper(domainName, siteName, dcFlags).Keys)
{
if (!hashtable.Contains(str))
{
hashtable.Add(str, null);
}
}
}
}
foreach (string str2 in hashtable.Keys)
{
DirectoryContext context2 = Utils.GetNewDirectoryContext(str2, DirectoryContextType.DirectoryServer, context);
if ((dcFlags & 0x40L) != 0L)
{
list.Add(new GlobalCatalog(context2, str2));
}
else
{
list.Add(new DomainController(context2, str2));
}
}
return(list);
}
private unsafe void FreeReplicaInfo(DS_REPL_INFO_TYPE type, IntPtr value, SafeLibraryHandle libHandle)
{
if (value != (IntPtr)0)
{
// call DsReplicaFreeInfo
var dsReplicaFreeInfo = (delegate * unmanaged <int, IntPtr, int>)global::Interop.Kernel32.GetProcAddress(libHandle, "DsReplicaFreeInfo");
if (dsReplicaFreeInfo == null)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
dsReplicaFreeInfo((int)type, value);
}
}
private void FreeReplicaInfo(DS_REPL_INFO_TYPE type, IntPtr value, LoadLibrarySafeHandle libHandle)
{
if (value != IntPtr.Zero)
{
IntPtr procAddress = System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaFreeInfo");
if (procAddress == IntPtr.Zero)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaFreeInfo delegateForFunctionPointer = (System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaFreeInfo)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaFreeInfo));
delegateForFunctionPointer((int)type, value);
}
}
internal static DomainControllerInfo GetDomainControllerInfo(string computerName, string domainName, string siteName, long flags)
{
DomainControllerInfo domainControllerInfo = null;
int num = Locator.DsGetDcNameWrapper(computerName, domainName, siteName, flags, out domainControllerInfo);
if (num == 0)
{
return(domainControllerInfo);
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(num, domainName);
}
}
private static void ValidateTrust(PolicySafeHandle handle, LSA_UNICODE_STRING trustedDomainName, string? sourceName, string? targetName, bool isForest, int direction, string serverName)
{
IntPtr buffer = (IntPtr)0;
// get trust information
int result = UnsafeNativeMethods.LsaQueryTrustedDomainInfoByName(handle, trustedDomainName, TRUSTED_INFORMATION_CLASS.TrustedDomainInformationEx, ref buffer);
if (result != 0)
{
int win32Error = UnsafeNativeMethods.LsaNtStatusToWinError(result);
// 2 ERROR_FILE_NOT_FOUND <--> 0xc0000034 STATUS_OBJECT_NAME_NOT_FOUND
if (win32Error == STATUS_OBJECT_NAME_NOT_FOUND)
{
if (isForest)
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.ForestTrustDoesNotExist, sourceName, targetName), typeof(ForestTrustRelationshipInformation), null);
else
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.DomainTrustDoesNotExist, sourceName, targetName), typeof(TrustRelationshipInformation), null);
}
else
throw ExceptionHelper.GetExceptionFromErrorCode(win32Error, serverName);
}
Debug.Assert(buffer != (IntPtr)0);
try
{
TRUSTED_DOMAIN_INFORMATION_EX domainInfo = new TRUSTED_DOMAIN_INFORMATION_EX();
Marshal.PtrToStructure(buffer, domainInfo);
// validate this is the trust that the user refers to
ValidateTrustAttribute(domainInfo, isForest, sourceName, targetName);
// validate trust direction if applicable
if (direction != 0)
{
if ((direction & domainInfo.TrustDirection) == 0)
{
if (isForest)
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.WrongTrustDirection, sourceName, targetName, (TrustDirection)direction), typeof(ForestTrustRelationshipInformation), null);
else
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.WrongTrustDirection, sourceName, targetName, (TrustDirection)direction), typeof(TrustRelationshipInformation), null);
}
}
}
finally
{
if (buffer != (IntPtr)0)
UnsafeNativeMethods.LsaFreeMemory(buffer);
}
}
private void FreeReplicaInfo(DS_REPL_INFO_TYPE type, IntPtr value, LoadLibrarySafeHandle libHandle)
{
if (value != (IntPtr)0)
{
// call DsReplicaFreeInfo
IntPtr functionPtr = UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaFreeInfo");
if (functionPtr == (IntPtr)0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
UnsafeNativeMethods.DsReplicaFreeInfo dsReplicaFreeInfo = (UnsafeNativeMethods.DsReplicaFreeInfo)Marshal.GetDelegateForFunctionPointer(functionPtr, typeof(UnsafeNativeMethods.DsReplicaFreeInfo));
dsReplicaFreeInfo((int)type, value);
}
}
internal void SyncReplicaAllHelper(IntPtr handle, SyncReplicaFromAllServersCallback syncAllFunctionPointer, string partition, SyncFromAllServersOptions option, SyncUpdateCallback callback, LoadLibrarySafeHandle libHandle)
{
IntPtr intPtr = (IntPtr)0;
if (this.Partitions.Contains(partition))
{
IntPtr procAddress = UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaSyncAllW");
if (procAddress != (IntPtr)0)
{
UnsafeNativeMethods.DsReplicaSyncAllW delegateForFunctionPointer = (UnsafeNativeMethods.DsReplicaSyncAllW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(UnsafeNativeMethods.DsReplicaSyncAllW));
int num = delegateForFunctionPointer(handle, partition, (int)option | 4, syncAllFunctionPointer, (IntPtr)0, ref intPtr);
try
{
if (intPtr == (IntPtr)0)
{
if (num != 0)
{
throw new SyncFromAllServersOperationException(ExceptionHelper.GetErrorMessage(num, false));
}
}
else
{
SyncFromAllServersOperationException syncFromAllServersOperationException = ExceptionHelper.CreateSyncAllException(intPtr, false);
if (syncFromAllServersOperationException != null)
{
throw syncFromAllServersOperationException;
}
}
}
finally
{
if (intPtr != (IntPtr)0)
{
UnsafeNativeMethods.LocalFree(intPtr);
}
}
return;
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
}
else
{
throw new ArgumentException(Res.GetString("ServerNotAReplica"), "partition");
}
}
internal void CheckConsistencyHelper(IntPtr dsHandle, LoadLibrarySafeHandle libHandle)
{
IntPtr procAddress = System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaConsistencyCheck");
if (procAddress == IntPtr.Zero)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaConsistencyCheck delegateForFunctionPointer = (System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaConsistencyCheck)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaConsistencyCheck));
int errorCode = delegateForFunctionPointer(dsHandle, 0, 0);
if (errorCode != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode, this.Name);
}
}
internal unsafe void CheckConsistencyHelper(IntPtr dsHandle, SafeLibraryHandle libHandle)
{
// call DsReplicaConsistencyCheck
var replicaConsistencyCheck = (delegate * unmanaged <IntPtr, int, int, int>)global::Interop.Kernel32.GetProcAddress(libHandle, "DsReplicaConsistencyCheck");
if (replicaConsistencyCheck == null)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
int result = replicaConsistencyCheck(dsHandle, 0, 0);
if (result != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(result, Name);
}
}
internal ForestTrustDomainInformation(int flag, LSA_FOREST_TRUST_DOMAIN_INFO domainInfo, LARGE_INTEGER time)
{
_status = (ForestTrustDomainStatus)flag;
DnsName = Marshal.PtrToStringUni(domainInfo.DNSNameBuffer, domainInfo.DNSNameLength / 2);
NetBiosName = Marshal.PtrToStringUni(domainInfo.NetBIOSNameBuffer, domainInfo.NetBIOSNameLength / 2);
string sidLocal;
global::Interop.BOOL result = global::Interop.Advapi32.ConvertSidToStringSid(domainInfo.sid, out sidLocal);
if (result == global::Interop.BOOL.FALSE)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
DomainSid = sidLocal;
this.time = time;
}
private unsafe ArrayList GetSites()
{
ArrayList sites = new ArrayList();
int result = 0;
IntPtr dsHandle = IntPtr.Zero;
IntPtr authIdentity = IntPtr.Zero;
IntPtr sitesPtr = IntPtr.Zero;
try
{
// get the directory handle
GetDSHandle(out dsHandle, out authIdentity);
// Get the sites within the forest
// call DsListSites
/*DWORD DsListSites(
* HANDLE hDs,
* PDS_NAME_RESULT* ppSites
* );*/
var dsListSites = (delegate * unmanaged <IntPtr, IntPtr *, int>)global::Interop.Kernel32.GetProcAddress(DirectoryContext.ADHandle, "DsListSitesW");
if (dsListSites == null)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastPInvokeError());
}
result = dsListSites(dsHandle, &sitesPtr);
if (result == 0)
{
try
{
DsNameResult dsNameResult = new DsNameResult();
Marshal.PtrToStructure(sitesPtr, dsNameResult);
IntPtr currentItem = dsNameResult.items;
for (int i = 0; i < dsNameResult.itemCount; i++)
{
DsNameResultItem dsNameResultItem = new DsNameResultItem();
Marshal.PtrToStructure(currentItem, dsNameResultItem);
if (dsNameResultItem.status == NativeMethods.DsNameNoError)
{
string siteName = Utils.GetDNComponents(dsNameResultItem.name !)[0].Value !;
// an existing site
sites.Add(new ActiveDirectorySite(_context, siteName, true));
}
internal void CheckConsistencyHelper(IntPtr dsHandle, LoadLibrarySafeHandle libHandle)
{
// call DsReplicaConsistencyCheck
IntPtr functionPtr = UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaConsistencyCheck");
if (functionPtr == (IntPtr)0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
UnsafeNativeMethods.DsReplicaConsistencyCheck replicaConsistencyCheck = (UnsafeNativeMethods.DsReplicaConsistencyCheck)Marshal.GetDelegateForFunctionPointer(functionPtr, typeof(UnsafeNativeMethods.DsReplicaConsistencyCheck));
int result = replicaConsistencyCheck(dsHandle, 0, 0);
if (result != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(result, Name);
}
}
internal static GlobalCatalog FindOneInternal(DirectoryContext context, string forestName, string siteName, LocatorOptions flag)
{
DomainControllerInfo info;
int errorCode = 0;
if ((siteName != null) && (siteName.Length == 0))
{
throw new ArgumentException(Res.GetString("EmptyStringParameter"), "siteName");
}
if ((flag & ~(LocatorOptions.AvoidSelf | LocatorOptions.ForceRediscovery | LocatorOptions.KdcRequired | LocatorOptions.TimeServerRequired | LocatorOptions.WriteableRequired)) != 0L)
{
throw new ArgumentException(Res.GetString("InvalidFlags"), "flag");
}
if (forestName == null)
{
DomainControllerInfo info2;
int num2 = Locator.DsGetDcNameWrapper(null, DirectoryContext.GetLoggedOnDomain(), null, 0x10L, out info2);
if (num2 == 0x54b)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ContextNotAssociatedWithDomain"), typeof(GlobalCatalog), null);
}
if (num2 != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
forestName = info2.DnsForestName;
}
errorCode = Locator.DsGetDcNameWrapper(null, forestName, siteName, flag | 80L, out info);
switch (errorCode)
{
case 0x54b:
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("GCNotFoundInForest", new object[] { forestName }), typeof(GlobalCatalog), null);
case 0x3ec:
throw new ArgumentException(Res.GetString("InvalidFlags"), "flag");
}
if (errorCode != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
string globalCatalogName = info.DomainControllerName.Substring(2);
return(new GlobalCatalog(Utils.GetNewDirectoryContext(globalCatalogName, DirectoryContextType.DirectoryServer, context), globalCatalogName));
}
internal bool isCurrentForest()
{
DomainControllerInfo domainControllerInfo = null;
bool flag = false;
DomainControllerInfo domainControllerInfo1 = Locator.GetDomainControllerInfo(null, this.name, null, (long)0x40000010);
string loggedOnDomain = DirectoryContext.GetLoggedOnDomain();
int num = Locator.DsGetDcNameWrapper(null, loggedOnDomain, null, (long)0x40000010, out domainControllerInfo);
if (num != 0)
{
if (num != 0x54b)
{
throw ExceptionHelper.GetExceptionFromErrorCode(num);
}
}
else
{
flag = Utils.Compare(domainControllerInfo1.DnsForestName, domainControllerInfo.DnsForestName) == 0;
}
return(flag);
}
private static void ValidateTrust(PolicySafeHandle handle, LSA_UNICODE_STRING trustedDomainName, string sourceName, string targetName, bool isForest, int direction, string serverName)
{
IntPtr zero = IntPtr.Zero;
int status = UnsafeNativeMethods.LsaQueryTrustedDomainInfoByName(handle, trustedDomainName, TRUSTED_INFORMATION_CLASS.TrustedDomainInformationEx, ref zero);
if (status != 0)
{
int errorCode = UnsafeNativeMethods.LsaNtStatusToWinError(status);
if (errorCode != STATUS_OBJECT_NAME_NOT_FOUND)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode, serverName);
}
if (isForest)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ForestTrustDoesNotExist", new object[] { sourceName, targetName }), typeof(ForestTrustRelationshipInformation), null);
}
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("DomainTrustDoesNotExist", new object[] { sourceName, targetName }), typeof(TrustRelationshipInformation), null);
}
try
{
TRUSTED_DOMAIN_INFORMATION_EX structure = new TRUSTED_DOMAIN_INFORMATION_EX();
Marshal.PtrToStructure(zero, structure);
ValidateTrustAttribute(structure, isForest, sourceName, targetName);
if ((direction != 0) && ((direction & structure.TrustDirection) == 0))
{
if (isForest)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("WrongTrustDirection", new object[] { sourceName, targetName, (TrustDirection)direction }), typeof(ForestTrustRelationshipInformation), null);
}
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("WrongTrustDirection", new object[] { sourceName, targetName, (TrustDirection)direction }), typeof(TrustRelationshipInformation), null);
}
}
finally
{
if (zero != IntPtr.Zero)
{
UnsafeNativeMethods.LsaFreeMemory(zero);
}
}
}
internal void SyncReplicaAllHelper(IntPtr handle, SyncReplicaFromAllServersCallback syncAllFunctionPointer, string partition, SyncFromAllServersOptions option, SyncUpdateCallback callback, LoadLibrarySafeHandle libHandle)
{
IntPtr zero = IntPtr.Zero;
if (!this.Partitions.Contains(partition))
{
throw new ArgumentException(Res.GetString("ServerNotAReplica"), "partition");
}
IntPtr procAddress = System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaSyncAllW");
if (procAddress == IntPtr.Zero)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaSyncAllW delegateForFunctionPointer = (System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaSyncAllW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaSyncAllW));
int errorCode = delegateForFunctionPointer(handle, partition, ((int)option) | 4, syncAllFunctionPointer, IntPtr.Zero, ref zero);
try
{
if (zero != IntPtr.Zero)
{
SyncFromAllServersOperationException exception = ExceptionHelper.CreateSyncAllException(zero, false);
if (exception != null)
{
throw exception;
}
}
else if (errorCode != 0)
{
throw new SyncFromAllServersOperationException(ExceptionHelper.GetErrorMessage(errorCode, false));
}
}
finally
{
if (zero != IntPtr.Zero)
{
System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.LocalFree(zero);
}
}
}
internal void CheckConsistencyHelper(IntPtr dsHandle, LoadLibrarySafeHandle libHandle)
{
IntPtr procAddress = UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaConsistencyCheck");
if (procAddress != (IntPtr)0)
{
UnsafeNativeMethods.DsReplicaConsistencyCheck delegateForFunctionPointer = (UnsafeNativeMethods.DsReplicaConsistencyCheck)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(UnsafeNativeMethods.DsReplicaConsistencyCheck));
int num = delegateForFunctionPointer(dsHandle, 0, 0);
if (num == 0)
{
return;
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(num, this.Name);
}
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
}
internal ForestTrustDomainInformation(int flag, LSA_FOREST_TRUST_DOMAIN_INFO domainInfo, LARGE_INTEGER time)
{
_status = (ForestTrustDomainStatus)flag;
DnsName = Marshal.PtrToStringUni(domainInfo.DNSNameBuffer, domainInfo.DNSNameLength / 2);
NetBiosName = Marshal.PtrToStringUni(domainInfo.NetBIOSNameBuffer, domainInfo.NetBIOSNameLength / 2);
IntPtr ptr = (IntPtr)0;
int result = UnsafeNativeMethods.ConvertSidToStringSidW(domainInfo.sid, ref ptr);
if (result == 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
try
{
DomainSid = Marshal.PtrToStringUni(ptr) !;
}
finally
{
UnsafeNativeMethods.LocalFree(ptr);
}
this.time = time;
}
