public static IEnumerable<DomainController> FindAllDomainControllers(string domain)
{
try
{
var context = new DirectoryContext(DirectoryContextType.Domain, domain);
var searchResult = DomainController.FindAll(context);
var dcs = new DomainController[searchResult.Count];
searchResult.CopyTo(dcs, 0);
return dcs.AsEnumerable();
}
catch (Exception)
{
return null;
}
}
private DirectoryServer GetSchemaRoleOwner()
{
DirectoryServer server2;
try
{
this.schemaEntry.RefreshCache();
if (base.context.isADAMConfigSet())
{
string adamDnsHostNameFromNTDSA = Utils.GetAdamDnsHostNameFromNTDSA(base.context, (string)PropertyManager.GetPropertyValue(base.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
return(new AdamInstance(Utils.GetNewDirectoryContext(adamDnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, base.context), adamDnsHostNameFromNTDSA));
}
DirectoryServer server = null;
if (Utils.CheckCapability(base.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE), Capability.ActiveDirectory))
{
string dnsHostNameFromNTDSA = Utils.GetDnsHostNameFromNTDSA(base.context, (string)PropertyManager.GetPropertyValue(base.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
server = new DomainController(Utils.GetNewDirectoryContext(dnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, base.context), dnsHostNameFromNTDSA);
}
else
{
string adamInstanceName = Utils.GetAdamDnsHostNameFromNTDSA(base.context, (string)PropertyManager.GetPropertyValue(base.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
server = new AdamInstance(Utils.GetNewDirectoryContext(adamInstanceName, DirectoryContextType.DirectoryServer, base.context), adamInstanceName);
}
server2 = server;
}
catch (COMException exception)
{
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception);
}
return(server2);
}
internal static DomainController FindOneWithCredentialValidation(DirectoryContext context, string siteName, LocatorOptions flag)
{
bool flag2 = false;
bool flag3 = false;
context = new DirectoryContext(context);
DomainController dc = FindOneInternal(context, context.Name, siteName, flag);
try
{
ValidateCredential(dc, context);
flag3 = true;
}
catch (COMException exception)
{
if (exception.ErrorCode != -2147016646)
{
throw System.DirectoryServices.ActiveDirectory.ExceptionHelper.GetExceptionFromCOMException(context, exception);
}
if ((flag & LocatorOptions.ForceRediscovery) != 0L)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("DCNotFoundInDomain", new object[] { context.Name }), typeof(DomainController), null);
}
flag2 = true;
}
finally
{
if (!flag3)
{
dc.Dispose();
}
}
if (flag2)
{
flag3 = false;
dc = FindOneInternal(context, context.Name, siteName, flag | LocatorOptions.ForceRediscovery);
try
{
ValidateCredential(dc, context);
flag3 = true;
}
catch (COMException exception2)
{
if (exception2.ErrorCode == -2147016646)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("DCNotFoundInDomain", new object[] { context.Name }), typeof(DomainController), null);
}
throw System.DirectoryServices.ActiveDirectory.ExceptionHelper.GetExceptionFromCOMException(context, exception2);
}
finally
{
if (!flag3)
{
dc.Dispose();
}
}
}
return(dc);
}
public int IndexOf(DomainController domainController)
{
Contract.Requires(domainController != null);
Contract.Ensures(Contract.Result <int>() >= -1);
Contract.Ensures(Contract.Result <int>() < this.Count);
return(default(int));
}
public int IndexOf(DomainController domainController)
{
Contract.Requires(domainController != null);
Contract.Ensures(Contract.Result<int>() >= -1);
Contract.Ensures(Contract.Result<int>() < this.Count);
return default(int);
}
internal static void ValidateCredential(DomainController dc, DirectoryContext context)
{
DirectoryEntry entry;
if (DirectoryContext.ServerBindSupported)
{
entry = new DirectoryEntry("LDAP://" + dc.Name + "/RootDSE", context.UserName, context.Password, Utils.DefaultAuthType | AuthenticationTypes.ServerBind);
}
else
{
entry = new DirectoryEntry("LDAP://" + dc.Name + "/RootDSE", context.UserName, context.Password, Utils.DefaultAuthType);
}
entry.Bind(true);
}
public int IndexOf(DomainController domainController)
{
if (domainController == null)
throw new ArgumentNullException("domainController");
for (int i = 0; i < InnerList.Count; i++)
{
DomainController tmp = (DomainController)InnerList[i];
if (Utils.Compare(tmp.Name, domainController.Name) == 0)
{
return i;
}
}
return -1;
}
public ADDomainController(ActiveDirectoryContext Context, DomainController DomainController, ADDomain Domain, bool IsSiteServer, bool IsWritable)
{
this.context = Context;
this.Domain = Domain;
this.DomainController = DomainController;
this.Name = DomainController.Name;
this.SiteName = DomainController.SiteName;
this.IsSiteServer = IsSiteServer;
this.IsWritable = IsWritable;
this.AvailableWhen = null;
}
public bool Contains(DomainController domainController)
{
if (domainController == null)
{
throw new ArgumentNullException("domainController");
}
for (int i = 0; i < base.InnerList.Count; i++)
{
DomainController controller = (DomainController) base.InnerList[i];
if (Utils.Compare(controller.Name, domainController.Name) == 0)
{
return true;
}
}
return false;
}
public int IndexOf(DomainController domainController)
{
if (domainController == null)
{
throw new ArgumentNullException("domainController");
}
for (int i = 0; i < base.InnerList.Count; i++)
{
DomainController controller = (DomainController)base.InnerList[i];
if (Utils.Compare(controller.Name, domainController.Name) == 0)
{
return(i);
}
}
return(-1);
}
public int IndexOf(DomainController domainController)
{
if (domainController == null)
{
throw new ArgumentNullException(nameof(domainController));
}
for (int i = 0; i < InnerList.Count; i++)
{
DomainController tmp = (DomainController)InnerList[i];
if (Utils.Compare(tmp.Name, domainController.Name) == 0)
{
return(i);
}
}
return(-1);
}
public bool Contains(DomainController domainController)
{
if (domainController == null)
{
throw new ArgumentNullException("domainController");
}
for (int i = 0; i < InnerList.Count; i++)
{
DomainController tmp = (DomainController)InnerList[i];
if (Utils.Compare(tmp.Name, domainController.Name) == 0)
{
return(true);
}
}
return(false);
}
private DirectoryServer GetSchemaRoleOwner()
{
try
{
_schemaEntry.RefreshCache();
if (context.isADAMConfigSet())
{
// ADAM
string adamInstName = Utils.GetAdamDnsHostNameFromNTDSA(context, (string)PropertyManager.GetPropertyValue(context, _schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext adamInstContext = Utils.GetNewDirectoryContext(adamInstName, DirectoryContextType.DirectoryServer, context);
return(new AdamInstance(adamInstContext, adamInstName));
}
else
{
// could be AD or adam server
DirectoryServer server = null;
DirectoryEntry rootDSE = directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if (Utils.CheckCapability(rootDSE, Capability.ActiveDirectory))
{
string dcName = Utils.GetDnsHostNameFromNTDSA(context, (string)PropertyManager.GetPropertyValue(context, _schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext dcContext = Utils.GetNewDirectoryContext(dcName, DirectoryContextType.DirectoryServer, context);
server = new DomainController(dcContext, dcName);
}
else
{
// ADAM case again
string adamInstName = Utils.GetAdamDnsHostNameFromNTDSA(context, (string)PropertyManager.GetPropertyValue(context, _schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext adamInstContext = Utils.GetNewDirectoryContext(adamInstName, DirectoryContextType.DirectoryServer, context);
server = new AdamInstance(adamInstContext, adamInstName);
}
return(server);
}
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
}
private DirectoryServer GetSchemaRoleOwner()
{
DirectoryServer adamInstance;
DirectoryServer directoryServer;
try
{
this.schemaEntry.RefreshCache();
if (!this.context.isADAMConfigSet())
{
DirectoryEntry cachedDirectoryEntry = this.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if (!Utils.CheckCapability(cachedDirectoryEntry, Capability.ActiveDirectory))
{
string adamDnsHostNameFromNTDSA = Utils.GetAdamDnsHostNameFromNTDSA(this.context, (string)PropertyManager.GetPropertyValue(this.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext newDirectoryContext = Utils.GetNewDirectoryContext(adamDnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, this.context);
adamInstance = new AdamInstance(newDirectoryContext, adamDnsHostNameFromNTDSA);
}
else
{
string dnsHostNameFromNTDSA = Utils.GetDnsHostNameFromNTDSA(this.context, (string)PropertyManager.GetPropertyValue(this.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext directoryContext = Utils.GetNewDirectoryContext(dnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, this.context);
adamInstance = new DomainController(directoryContext, dnsHostNameFromNTDSA);
}
directoryServer = adamInstance;
}
else
{
string str = Utils.GetAdamDnsHostNameFromNTDSA(this.context, (string)PropertyManager.GetPropertyValue(this.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext newDirectoryContext1 = Utils.GetNewDirectoryContext(str, DirectoryContextType.DirectoryServer, this.context);
directoryServer = new AdamInstance(newDirectoryContext1, str);
}
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException);
}
return(directoryServer);
}
public int IndexOf(DomainController domainController)
{
if (domainController != null)
{
int num = 0;
while (num < base.InnerList.Count)
{
DomainController item = (DomainController)base.InnerList[num];
if (Utils.Compare(item.Name, domainController.Name) != 0)
{
num++;
}
else
{
return num;
}
}
return -1;
}
else
{
throw new ArgumentNullException("domainController");
}
}
private DirectoryServer GetSchemaRoleOwner()
{
DirectoryServer server2;
try
{
this.schemaEntry.RefreshCache();
if (base.context.isADAMConfigSet())
{
string adamDnsHostNameFromNTDSA = Utils.GetAdamDnsHostNameFromNTDSA(base.context, (string) PropertyManager.GetPropertyValue(base.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
return new AdamInstance(Utils.GetNewDirectoryContext(adamDnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, base.context), adamDnsHostNameFromNTDSA);
}
DirectoryServer server = null;
if (Utils.CheckCapability(base.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE), Capability.ActiveDirectory))
{
string dnsHostNameFromNTDSA = Utils.GetDnsHostNameFromNTDSA(base.context, (string) PropertyManager.GetPropertyValue(base.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
server = new DomainController(Utils.GetNewDirectoryContext(dnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, base.context), dnsHostNameFromNTDSA);
}
else
{
string adamInstanceName = Utils.GetAdamDnsHostNameFromNTDSA(base.context, (string) PropertyManager.GetPropertyValue(base.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
server = new AdamInstance(Utils.GetNewDirectoryContext(adamInstanceName, DirectoryContextType.DirectoryServer, base.context), adamInstanceName);
}
server2 = server;
}
catch (COMException exception)
{
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception);
}
return server2;
}
public void CopyTo(DomainController[] domainControllers, int index)
{
base.InnerList.CopyTo(domainControllers, index);
}
private void GetServers()
{
ADSearcher adSearcher = new ADSearcher(cachedEntry,
"(&(objectClass=server)(objectCategory=server))",
new string[] { "dNSHostName" },
SearchScope.Subtree);
SearchResultCollection results = null;
try
{
results = adSearcher.FindAll();
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
try
{
foreach (SearchResult result in results)
{
string hostName = (string)PropertyManager.GetSearchResultPropertyValue(result, PropertyManager.DnsHostName);
DirectoryEntry de = result.GetDirectoryEntry();
DirectoryEntry child = null;
DirectoryServer replica = null;
// make sure that the server is not demoted
try
{
child = de.Children.Find("CN=NTDS Settings", "nTDSDSA");
}
catch (COMException e)
{
if (e.ErrorCode == unchecked((int)0x80072030))
{
continue;
}
else
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
if (IsADAM)
{
int port = (int)PropertyManager.GetPropertyValue(context, child, PropertyManager.MsDSPortLDAP);
string fullHostName = hostName;
if (port != 389)
{
fullHostName = hostName + ":" + port;
}
replica = new AdamInstance(Utils.GetNewDirectoryContext(fullHostName, DirectoryContextType.DirectoryServer, context), fullHostName);
}
else
replica = new DomainController(Utils.GetNewDirectoryContext(hostName, DirectoryContextType.DirectoryServer, context), hostName);
_servers.Add(replica);
}
}
finally
{
results.Dispose();
}
}
public int IndexOf (DomainController domainController)
{
throw new NotImplementedException ();
}
private DirectoryServer FindDirectoryServerInternal(string siteName, bool forceRediscovery)
{
DomainControllerInfo domainControllerInfo = null;
LocatorOptions locatorOption = 0;
if (siteName == null || siteName.Length != 0)
{
if (this.committed)
{
if (forceRediscovery)
{
locatorOption = LocatorOptions.ForceRediscovery;
}
int num = Locator.DsGetDcNameWrapper(null, this.dnsName, siteName, (long)locatorOption | 0x8000, out domainControllerInfo);
if (num != 0x54b)
{
if (num == 0)
{
string str = domainControllerInfo.DomainControllerName.Substring(2);
DirectoryContext newDirectoryContext = Utils.GetNewDirectoryContext(str, DirectoryContextType.DirectoryServer, this.context);
DirectoryServer domainController = new DomainController(newDirectoryContext, str);
return domainController;
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(num);
}
}
else
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ReplicaNotFound"), typeof(DirectoryServer), null);
}
}
else
{
throw new InvalidOperationException(Res.GetString("CannotPerformOperationOnUncommittedObject"));
}
}
else
{
throw new ArgumentException(Res.GetString("EmptyStringParameter"), "siteName");
}
}
private void GetPreferredBridgeheadServers(ActiveDirectoryTransportType transport)
{
string str;
DirectoryServer domainController;
string str1 = string.Concat("CN=Servers,", PropertyManager.GetPropertyValue(this.context, this.cachedEntry, PropertyManager.DistinguishedName));
if (transport != ActiveDirectoryTransportType.Smtp)
{
str = string.Concat("CN=IP,CN=Inter-Site Transports,", this.siteDN);
}
else
{
str = string.Concat("CN=SMTP,CN=Inter-Site Transports,", this.siteDN);
}
DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, str1);
string[] strArrays = new string[2];
strArrays[0] = "dNSHostName";
strArrays[1] = "distinguishedName";
ADSearcher aDSearcher = new ADSearcher(directoryEntry, string.Concat("(&(objectClass=server)(objectCategory=Server)(bridgeheadTransportList=", Utils.GetEscapedFilterValue(str), "))"), strArrays, SearchScope.OneLevel);
SearchResultCollection searchResultCollections = null;
try
{
searchResultCollections = aDSearcher.FindAll();
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException);
}
try
{
DirectoryEntry directoryEntry1 = null;
foreach (SearchResult searchResult in searchResultCollections)
{
string searchResultPropertyValue = (string)PropertyManager.GetSearchResultPropertyValue(searchResult, PropertyManager.DnsHostName);
DirectoryEntry directoryEntry2 = searchResult.GetDirectoryEntry();
try
{
directoryEntry1 = directoryEntry2.Children.Find("CN=NTDS Settings", "nTDSDSA");
}
catch (COMException cOMException3)
{
COMException cOMException2 = cOMException3;
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException2);
}
if (!this.IsADAM)
{
domainController = new DomainController(Utils.GetNewDirectoryContext(searchResultPropertyValue, DirectoryContextType.DirectoryServer, this.context), searchResultPropertyValue);
}
else
{
int propertyValue = (int)PropertyManager.GetPropertyValue(this.context, directoryEntry1, PropertyManager.MsDSPortLDAP);
string str2 = searchResultPropertyValue;
if (propertyValue != 0x185)
{
str2 = string.Concat(searchResultPropertyValue, ":", propertyValue);
}
domainController = new AdamInstance(Utils.GetNewDirectoryContext(str2, DirectoryContextType.DirectoryServer, this.context), str2);
}
if (transport != ActiveDirectoryTransportType.Smtp)
{
this.RPCBridgeheadServers.Add(domainController);
}
else
{
this.SMTPBridgeheadServers.Add(domainController);
}
}
}
finally
{
directoryEntry.Dispose();
searchResultCollections.Dispose();
}
}
private ReadOnlyDirectoryServerCollection GetBridgeheadServers()
{
DirectoryServer domainController;
NativeComInterfaces.IAdsPathname pathname = (NativeComInterfaces.IAdsPathname)(new NativeComInterfaces.Pathname());
pathname.EscapedMode = 4;
ReadOnlyDirectoryServerCollection readOnlyDirectoryServerCollection = new ReadOnlyDirectoryServerCollection();
if (this.existing)
{
Hashtable hashtables = new Hashtable();
Hashtable hashtables1 = new Hashtable();
Hashtable hashtables2 = new Hashtable();
string str = string.Concat("CN=Servers,", (string)PropertyManager.GetPropertyValue(this.context, this.cachedEntry, PropertyManager.DistinguishedName));
DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, str);
try
{
string[] strArrays = new string[4];
strArrays[0] = "fromServer";
strArrays[1] = "distinguishedName";
strArrays[2] = "dNSHostName";
strArrays[3] = "objectCategory";
ADSearcher aDSearcher = new ADSearcher(directoryEntry, "(|(objectCategory=server)(objectCategory=NTDSConnection))", strArrays, SearchScope.Subtree, true, true);
SearchResultCollection searchResultCollections = null;
try
{
searchResultCollections = aDSearcher.FindAll();
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException);
}
try
{
foreach (SearchResult searchResult in searchResultCollections)
{
string searchResultPropertyValue = (string)PropertyManager.GetSearchResultPropertyValue(searchResult, PropertyManager.ObjectCategory);
if (Utils.Compare(searchResultPropertyValue, 0, "CN=Server".Length, "CN=Server", 0, "CN=Server".Length) != 0)
{
continue;
}
hashtables2.Add((string)PropertyManager.GetSearchResultPropertyValue(searchResult, PropertyManager.DistinguishedName), (string)PropertyManager.GetSearchResultPropertyValue(searchResult, PropertyManager.DnsHostName));
}
foreach (SearchResult searchResult1 in searchResultCollections)
{
string searchResultPropertyValue1 = (string)PropertyManager.GetSearchResultPropertyValue(searchResult1, PropertyManager.ObjectCategory);
if (Utils.Compare(searchResultPropertyValue1, 0, "CN=Server".Length, "CN=Server", 0, "CN=Server".Length) == 0)
{
continue;
}
string str1 = (string)PropertyManager.GetSearchResultPropertyValue(searchResult1, PropertyManager.FromServer);
string partialDN = Utils.GetPartialDN(str1, 3);
pathname.Set(partialDN, 4);
partialDN = pathname.Retrieve(11);
partialDN = partialDN.Substring(3);
string partialDN1 = Utils.GetPartialDN((string)PropertyManager.GetSearchResultPropertyValue(searchResult1, PropertyManager.DistinguishedName), 2);
if (hashtables.Contains(partialDN1))
{
continue;
}
string item = (string)hashtables2[partialDN1];
if (!hashtables1.Contains(partialDN1))
{
hashtables1.Add(partialDN1, item);
}
if (Utils.Compare((string)PropertyManager.GetPropertyValue(this.context, this.cachedEntry, PropertyManager.Cn), partialDN) == 0)
{
continue;
}
hashtables.Add(partialDN1, item);
hashtables1.Remove(partialDN1);
}
}
finally
{
searchResultCollections.Dispose();
}
}
finally
{
directoryEntry.Dispose();
}
if (hashtables1.Count != 0)
{
DirectoryEntry directoryEntry1 = DirectoryEntryManager.GetDirectoryEntry(this.context, this.siteDN);
StringBuilder stringBuilder = new StringBuilder(100);
if (hashtables1.Count > 1)
{
stringBuilder.Append("(|");
}
foreach (DictionaryEntry hashtable in hashtables1)
{
stringBuilder.Append("(fromServer=");
stringBuilder.Append("CN=NTDS Settings,");
stringBuilder.Append(Utils.GetEscapedFilterValue((string)hashtable.Key));
stringBuilder.Append(")");
}
if (hashtables1.Count > 1)
{
stringBuilder.Append(")");
}
string[] strArrays1 = new string[2];
strArrays1[0] = "fromServer";
strArrays1[1] = "distinguishedName";
ADSearcher aDSearcher1 = new ADSearcher(directoryEntry1, string.Concat("(&(objectClass=nTDSConnection)(objectCategory=NTDSConnection)", stringBuilder.ToString(), ")"), strArrays1, SearchScope.Subtree);
SearchResultCollection searchResultCollections1 = null;
try
{
searchResultCollections1 = aDSearcher1.FindAll();
}
catch (COMException cOMException3)
{
COMException cOMException2 = cOMException3;
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException2);
}
try
{
foreach (SearchResult searchResult2 in searchResultCollections1)
{
string searchResultPropertyValue2 = (string)PropertyManager.GetSearchResultPropertyValue(searchResult2, PropertyManager.FromServer);
string str2 = searchResultPropertyValue2.Substring(17);
if (!hashtables1.Contains(str2))
{
continue;
}
string partialDN2 = Utils.GetPartialDN((string)PropertyManager.GetSearchResultPropertyValue(searchResult2, PropertyManager.DistinguishedName), 4);
pathname.Set(partialDN2, 4);
partialDN2 = pathname.Retrieve(11);
partialDN2 = partialDN2.Substring(3);
if (Utils.Compare(partialDN2, (string)PropertyManager.GetPropertyValue(this.context, this.cachedEntry, PropertyManager.Cn)) == 0)
{
continue;
}
string item1 = (string)hashtables1[str2];
hashtables1.Remove(str2);
hashtables.Add(str2, item1);
}
}
finally
{
searchResultCollections1.Dispose();
directoryEntry1.Dispose();
}
}
foreach (DictionaryEntry dictionaryEntry in hashtables)
{
string value = (string)dictionaryEntry.Value;
if (!this.IsADAM)
{
domainController = new DomainController(Utils.GetNewDirectoryContext(value, DirectoryContextType.DirectoryServer, this.context), value);
}
else
{
DirectoryEntry directoryEntry2 = DirectoryEntryManager.GetDirectoryEntry(this.context, string.Concat("CN=NTDS Settings,", dictionaryEntry.Key));
int propertyValue = (int)PropertyManager.GetPropertyValue(this.context, directoryEntry2, PropertyManager.MsDSPortLDAP);
string str3 = value;
if (propertyValue != 0x185)
{
str3 = string.Concat(value, ":", propertyValue);
}
domainController = new AdamInstance(Utils.GetNewDirectoryContext(str3, DirectoryContextType.DirectoryServer, this.context), str3);
}
readOnlyDirectoryServerCollection.Add(domainController);
}
}
return readOnlyDirectoryServerCollection;
}
private ReadOnlyDirectoryServerCollection GetBridgeheadServers()
{
NativeComInterfaces.IAdsPathname pathname = (NativeComInterfaces.IAdsPathname) new NativeComInterfaces.Pathname();
pathname.EscapedMode = 4;
ReadOnlyDirectoryServerCollection servers = new ReadOnlyDirectoryServerCollection();
if (this.existing)
{
Hashtable hashtable = new Hashtable();
Hashtable hashtable2 = new Hashtable();
Hashtable hashtable3 = new Hashtable();
string dn = "CN=Servers," + ((string) PropertyManager.GetPropertyValue(this.context, this.cachedEntry, PropertyManager.DistinguishedName));
using (DirectoryEntry entry = DirectoryEntryManager.GetDirectoryEntry(this.context, dn))
{
ADSearcher searcher = new ADSearcher(entry, "(|(objectCategory=server)(objectCategory=NTDSConnection))", new string[] { "fromServer", "distinguishedName", "dNSHostName", "objectCategory" }, SearchScope.Subtree, true, true);
SearchResultCollection results = null;
try
{
results = searcher.FindAll();
}
catch (COMException exception)
{
throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception);
}
try
{
foreach (SearchResult result in results)
{
string searchResultPropertyValue = (string) PropertyManager.GetSearchResultPropertyValue(result, PropertyManager.ObjectCategory);
if (Utils.Compare(searchResultPropertyValue, 0, "CN=Server".Length, "CN=Server", 0, "CN=Server".Length) == 0)
{
hashtable3.Add((string) PropertyManager.GetSearchResultPropertyValue(result, PropertyManager.DistinguishedName), (string) PropertyManager.GetSearchResultPropertyValue(result, PropertyManager.DnsHostName));
}
}
foreach (SearchResult result2 in results)
{
string str3 = (string) PropertyManager.GetSearchResultPropertyValue(result2, PropertyManager.ObjectCategory);
if (Utils.Compare(str3, 0, "CN=Server".Length, "CN=Server", 0, "CN=Server".Length) != 0)
{
string distinguishedName = (string) PropertyManager.GetSearchResultPropertyValue(result2, PropertyManager.FromServer);
string partialDN = Utils.GetPartialDN(distinguishedName, 3);
pathname.Set(partialDN, 4);
partialDN = pathname.Retrieve(11).Substring(3);
string key = Utils.GetPartialDN((string) PropertyManager.GetSearchResultPropertyValue(result2, PropertyManager.DistinguishedName), 2);
if (!hashtable.Contains(key))
{
string str7 = (string) hashtable3[key];
if (!hashtable2.Contains(key))
{
hashtable2.Add(key, str7);
}
if (Utils.Compare((string) PropertyManager.GetPropertyValue(this.context, this.cachedEntry, PropertyManager.Cn), partialDN) != 0)
{
hashtable.Add(key, str7);
hashtable2.Remove(key);
}
}
}
}
}
finally
{
results.Dispose();
}
}
if (hashtable2.Count != 0)
{
DirectoryEntry searchRoot = DirectoryEntryManager.GetDirectoryEntry(this.context, this.siteDN);
StringBuilder builder = new StringBuilder(100);
if (hashtable2.Count > 1)
{
builder.Append("(|");
}
foreach (DictionaryEntry entry3 in hashtable2)
{
builder.Append("(fromServer=");
builder.Append("CN=NTDS Settings,");
builder.Append(Utils.GetEscapedFilterValue((string) entry3.Key));
builder.Append(")");
}
if (hashtable2.Count > 1)
{
builder.Append(")");
}
ADSearcher searcher2 = new ADSearcher(searchRoot, "(&(objectClass=nTDSConnection)(objectCategory=NTDSConnection)" + builder.ToString() + ")", new string[] { "fromServer", "distinguishedName" }, SearchScope.Subtree);
SearchResultCollection results2 = null;
try
{
results2 = searcher2.FindAll();
}
catch (COMException exception2)
{
throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception2);
}
try
{
foreach (SearchResult result3 in results2)
{
string str9 = ((string) PropertyManager.GetSearchResultPropertyValue(result3, PropertyManager.FromServer)).Substring(0x11);
if (hashtable2.Contains(str9))
{
string bstrADsPath = Utils.GetPartialDN((string) PropertyManager.GetSearchResultPropertyValue(result3, PropertyManager.DistinguishedName), 4);
pathname.Set(bstrADsPath, 4);
if (Utils.Compare(pathname.Retrieve(11).Substring(3), (string) PropertyManager.GetPropertyValue(this.context, this.cachedEntry, PropertyManager.Cn)) != 0)
{
string str11 = (string) hashtable2[str9];
hashtable2.Remove(str9);
hashtable.Add(str9, str11);
}
}
}
}
finally
{
results2.Dispose();
searchRoot.Dispose();
}
}
DirectoryEntry directoryEntry = null;
foreach (DictionaryEntry entry5 in hashtable)
{
DirectoryServer server = null;
string domainControllerName = (string) entry5.Value;
if (this.IsADAM)
{
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, "CN=NTDS Settings," + entry5.Key);
int num = (int) PropertyManager.GetPropertyValue(this.context, directoryEntry, PropertyManager.MsDSPortLDAP);
string adamInstanceName = domainControllerName;
if (num != 0x185)
{
adamInstanceName = domainControllerName + ":" + num;
}
server = new AdamInstance(Utils.GetNewDirectoryContext(adamInstanceName, DirectoryContextType.DirectoryServer, this.context), adamInstanceName);
}
else
{
server = new DomainController(Utils.GetNewDirectoryContext(domainControllerName, DirectoryContextType.DirectoryServer, this.context), domainControllerName);
}
servers.Add(server);
}
}
return servers;
}
public bool Contains(DomainController domainController)
{
Contract.Requires(domainController != null);
return default(bool);
}
internal static void ValidateCredential(DomainController dc, DirectoryContext context)
{
DirectoryEntry directoryEntry;
if (!DirectoryContext.ServerBindSupported)
{
directoryEntry = new DirectoryEntry(string.Concat("LDAP://", dc.Name, "/RootDSE"), context.UserName, context.Password, Utils.DefaultAuthType);
}
else
{
directoryEntry = new DirectoryEntry(string.Concat("LDAP://", dc.Name, "/RootDSE"), context.UserName, context.Password, Utils.DefaultAuthType | AuthenticationTypes.ServerBind);
}
//TODO: REVIEW: URGENT!!: directoryEntry.Bind(true);
}
private void GetServers()
{
ADSearcher searcher = new ADSearcher(this.cachedEntry, "(&(objectClass=server)(objectCategory=server))", new string[] { "dNSHostName" }, SearchScope.Subtree);
SearchResultCollection results = null;
try
{
results = searcher.FindAll();
}
catch (COMException exception)
{
throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception);
}
try
{
foreach (SearchResult result in results)
{
string searchResultPropertyValue = (string) PropertyManager.GetSearchResultPropertyValue(result, PropertyManager.DnsHostName);
DirectoryEntry directoryEntry = result.GetDirectoryEntry();
DirectoryEntry entry2 = null;
DirectoryServer server = null;
try
{
entry2 = directoryEntry.Children.Find("CN=NTDS Settings", "nTDSDSA");
}
catch (COMException exception2)
{
if (exception2.ErrorCode != -2147016656)
{
throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception2);
}
continue;
}
if (this.IsADAM)
{
int num = (int) PropertyManager.GetPropertyValue(this.context, entry2, PropertyManager.MsDSPortLDAP);
string adamInstanceName = searchResultPropertyValue;
if (num != 0x185)
{
adamInstanceName = searchResultPropertyValue + ":" + num;
}
server = new AdamInstance(Utils.GetNewDirectoryContext(adamInstanceName, DirectoryContextType.DirectoryServer, this.context), adamInstanceName);
}
else
{
server = new DomainController(Utils.GetNewDirectoryContext(searchResultPropertyValue, DirectoryContextType.DirectoryServer, this.context), searchResultPropertyValue);
}
this.servers.Add(server);
}
}
finally
{
results.Dispose();
}
}
public bool Contains(DomainController domainController)
{
Contract.Requires(domainController != null);
return(default(bool));
}
private ReadOnlyDirectoryServerCollection GetBridgeheadServers()
{
NativeComInterfaces.IAdsPathname pathCracker = (NativeComInterfaces.IAdsPathname)new NativeComInterfaces.Pathname();
// need to turn off the escaping for name
pathCracker.EscapedMode = NativeComInterfaces.ADS_ESCAPEDMODE_OFF_EX;
ReadOnlyDirectoryServerCollection collection = new ReadOnlyDirectoryServerCollection();
if (existing)
{
Hashtable bridgeHeadTable = new Hashtable();
Hashtable nonBridgHeadTable = new Hashtable();
Hashtable hostNameTable = new Hashtable();
const string ocValue = "CN=Server";
// get destination bridgehead servers
// first go to the servers container under the current site and then do a search to get the all server objects.
string serverContainer = "CN=Servers," + (string)PropertyManager.GetPropertyValue(context, cachedEntry, PropertyManager.DistinguishedName);
DirectoryEntry de = DirectoryEntryManager.GetDirectoryEntry(context, serverContainer);
try
{
// go through connection objects and find out its fromServer property.
ADSearcher adSearcher = new ADSearcher(de,
"(|(objectCategory=server)(objectCategory=NTDSConnection))",
new string[] { "fromServer", "distinguishedName", "dNSHostName", "objectCategory" },
SearchScope.Subtree,
true, /* need paged search */
true /* need cached result as we need to go back to the first record */);
SearchResultCollection conResults = null;
try
{
conResults = adSearcher.FindAll();
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
try
{
// find out whether fromServer indicates replicating from a server in another site.
foreach (SearchResult r in conResults)
{
string objectCategoryValue = (string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.ObjectCategory);
if (Utils.Compare(objectCategoryValue, 0, ocValue.Length, ocValue, 0, ocValue.Length) == 0)
{
hostNameTable.Add((string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.DistinguishedName), (string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.DnsHostName));
}
}
foreach (SearchResult r in conResults)
{
string objectCategoryValue = (string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.ObjectCategory);
if (Utils.Compare(objectCategoryValue, 0, ocValue.Length, ocValue, 0, ocValue.Length) != 0)
{
string fromServer = (string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.FromServer);
// escaping manipulation
string fromSite = Utils.GetPartialDN(fromServer, 3);
pathCracker.Set(fromSite, NativeComInterfaces.ADS_SETTYPE_DN);
fromSite = pathCracker.Retrieve(NativeComInterfaces.ADS_FORMAT_LEAF);
Debug.Assert(fromSite != null && Utils.Compare(fromSite, 0, 3, "CN=", 0, 3) == 0);
fromSite = fromSite.Substring(3);
string serverObjectName = Utils.GetPartialDN((string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.DistinguishedName), 2);
// don't know whether it is a bridgehead server yet.
if (!bridgeHeadTable.Contains(serverObjectName))
{
string hostName = (string)hostNameTable[serverObjectName];
// add if not yet done
if (!nonBridgHeadTable.Contains(serverObjectName))
nonBridgHeadTable.Add(serverObjectName, hostName);
// check whether from different site
if (Utils.Compare((string)PropertyManager.GetPropertyValue(context, cachedEntry, PropertyManager.Cn), fromSite) != 0)
{
// the server is a bridgehead server
bridgeHeadTable.Add(serverObjectName, hostName);
nonBridgHeadTable.Remove(serverObjectName);
}
}
}
}
}
finally
{
conResults.Dispose();
}
}
finally
{
de.Dispose();
}
// get source bridgehead server
if (nonBridgHeadTable.Count != 0)
{
// go to sites container to get all the connecdtion object that replicates from servers in the current sites that have
// not been determined whether it is a bridgehead server or not.
DirectoryEntry serverEntry = DirectoryEntryManager.GetDirectoryEntry(context, _siteDN);
// constructing the filter
StringBuilder str = new StringBuilder(100);
if (nonBridgHeadTable.Count > 1)
str.Append("(|");
foreach (DictionaryEntry val in nonBridgHeadTable)
{
str.Append("(fromServer=");
str.Append("CN=NTDS Settings,");
str.Append(Utils.GetEscapedFilterValue((string)val.Key));
str.Append(")");
}
if (nonBridgHeadTable.Count > 1)
str.Append(")");
ADSearcher adSearcher = new ADSearcher(serverEntry,
"(&(objectClass=nTDSConnection)(objectCategory=NTDSConnection)" + str.ToString() + ")",
new string[] { "fromServer", "distinguishedName" },
SearchScope.Subtree);
SearchResultCollection conResults = null;
try
{
conResults = adSearcher.FindAll();
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
try
{
foreach (SearchResult r in conResults)
{
string fromServer = (string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.FromServer);
string serverObject = fromServer.Substring(17);
if (nonBridgHeadTable.Contains(serverObject))
{
string otherSite = Utils.GetPartialDN((string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.DistinguishedName), 4);
// escaping manipulation
pathCracker.Set(otherSite, NativeComInterfaces.ADS_SETTYPE_DN);
otherSite = pathCracker.Retrieve(NativeComInterfaces.ADS_FORMAT_LEAF);
Debug.Assert(otherSite != null && Utils.Compare(otherSite, 0, 3, "CN=", 0, 3) == 0);
otherSite = otherSite.Substring(3);
// check whether from different sites
if (Utils.Compare(otherSite, (string)PropertyManager.GetPropertyValue(context, cachedEntry, PropertyManager.Cn)) != 0)
{
string val = (string)nonBridgHeadTable[serverObject];
nonBridgHeadTable.Remove(serverObject);
bridgeHeadTable.Add(serverObject, val);
}
}
}
}
finally
{
conResults.Dispose();
serverEntry.Dispose();
}
}
DirectoryEntry ADAMEntry = null;
foreach (DictionaryEntry e in bridgeHeadTable)
{
DirectoryServer replica = null;
string host = (string)e.Value;
// construct directoryreplica
if (IsADAM)
{
ADAMEntry = DirectoryEntryManager.GetDirectoryEntry(context, "CN=NTDS Settings," + e.Key);
int port = (int)PropertyManager.GetPropertyValue(context, ADAMEntry, PropertyManager.MsDSPortLDAP);
string fullhost = host;
if (port != 389)
{
fullhost = host + ":" + port;
}
replica = new AdamInstance(Utils.GetNewDirectoryContext(fullhost, DirectoryContextType.DirectoryServer, context), fullhost);
}
else
{
replica = new DomainController(Utils.GetNewDirectoryContext(host, DirectoryContextType.DirectoryServer, context), host);
}
collection.Add(replica);
}
}
return collection;
}
private void GetPreferredBridgeheadServers(ActiveDirectoryTransportType transport)
{
string serverContainerDN = "CN=Servers," + PropertyManager.GetPropertyValue(context, cachedEntry, PropertyManager.DistinguishedName);
string transportDN = null;
if (transport == ActiveDirectoryTransportType.Smtp)
transportDN = "CN=SMTP,CN=Inter-Site Transports," + _siteDN;
else
transportDN = "CN=IP,CN=Inter-Site Transports," + _siteDN;
DirectoryEntry de = DirectoryEntryManager.GetDirectoryEntry(context, serverContainerDN);
ADSearcher adSearcher = new ADSearcher(de,
"(&(objectClass=server)(objectCategory=Server)(bridgeheadTransportList=" + Utils.GetEscapedFilterValue(transportDN) + "))",
new string[] { "dNSHostName", "distinguishedName" },
SearchScope.OneLevel);
SearchResultCollection results = null;
try
{
results = adSearcher.FindAll();
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
try
{
DirectoryEntry ADAMEntry = null;
foreach (SearchResult result in results)
{
string hostName = (string)PropertyManager.GetSearchResultPropertyValue(result, PropertyManager.DnsHostName);
DirectoryEntry resultEntry = result.GetDirectoryEntry();
DirectoryServer replica = null;
try
{
ADAMEntry = resultEntry.Children.Find("CN=NTDS Settings", "nTDSDSA");
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
if (IsADAM)
{
int port = (int)PropertyManager.GetPropertyValue(context, ADAMEntry, PropertyManager.MsDSPortLDAP);
string fullHostName = hostName;
if (port != 389)
{
fullHostName = hostName + ":" + port;
}
replica = new AdamInstance(Utils.GetNewDirectoryContext(fullHostName, DirectoryContextType.DirectoryServer, context), fullHostName);
}
else
replica = new DomainController(Utils.GetNewDirectoryContext(hostName, DirectoryContextType.DirectoryServer, context), hostName);
if (transport == ActiveDirectoryTransportType.Smtp)
_SMTPBridgeheadServers.Add(replica);
else
_RPCBridgeheadServers.Add(replica);
}
}
finally
{
de.Dispose();
results.Dispose();
}
}
internal static GlobalCatalog FindOneWithCredentialValidation(DirectoryContext context, string siteName, LocatorOptions flag)
{
bool flag1 = false;
bool flag2 = false;
context = new DirectoryContext(context);
GlobalCatalog globalCatalog = GlobalCatalog.FindOneInternal(context, context.Name, siteName, flag);
using (globalCatalog)
{
if (flag2)
{
try
{
DomainController.ValidateCredential(globalCatalog, context);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
if (cOMException.ErrorCode != -2147016646)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException);
}
else
{
if ((flag & LocatorOptions.ForceRediscovery) != 0)
{
object[] name = new object[1];
name[0] = context.Name;
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("GCNotFoundInForest", name), typeof(GlobalCatalog), null);
}
else
{
flag1 = true;
}
}
}
}
}
if (flag1)
{
flag2 = false;
globalCatalog = GlobalCatalog.FindOneInternal(context, context.Name, siteName, flag | LocatorOptions.ForceRediscovery);
using (globalCatalog)
{
if (flag2)
{
try
{
DomainController.ValidateCredential(globalCatalog, context);
}
catch (COMException cOMException3)
{
COMException cOMException2 = cOMException3;
if (cOMException2.ErrorCode != -2147016646)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException2);
}
else
{
object[] objArray = new object[1];
objArray[0] = context.Name;
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("GCNotFoundInForest", objArray), typeof(GlobalCatalog), null);
}
}
}
}
}
return(globalCatalog);
}
public bool Contains(DomainController domainController)
{
throw new NotImplementedException();
}
internal static void ValidateCredential(DomainController dc, DirectoryContext context)
{
DirectoryEntry de;
if (DirectoryContext.ServerBindSupported)
{
de = new DirectoryEntry("LDAP://" + dc.Name + "/RootDSE", context.UserName, context.Password, Utils.DefaultAuthType | AuthenticationTypes.ServerBind);
}
else
{
de = new DirectoryEntry("LDAP://" + dc.Name + "/RootDSE", context.UserName, context.Password, Utils.DefaultAuthType);
}
de.Bind(true);
}
private DirectoryServer GetSchemaRoleOwner()
{
DirectoryServer adamInstance;
DirectoryServer directoryServer;
try
{
this.schemaEntry.RefreshCache();
if (!this.context.isADAMConfigSet())
{
DirectoryEntry cachedDirectoryEntry = this.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if (!Utils.CheckCapability(cachedDirectoryEntry, Capability.ActiveDirectory))
{
string adamDnsHostNameFromNTDSA = Utils.GetAdamDnsHostNameFromNTDSA(this.context, (string)PropertyManager.GetPropertyValue(this.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext newDirectoryContext = Utils.GetNewDirectoryContext(adamDnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, this.context);
adamInstance = new AdamInstance(newDirectoryContext, adamDnsHostNameFromNTDSA);
}
else
{
string dnsHostNameFromNTDSA = Utils.GetDnsHostNameFromNTDSA(this.context, (string)PropertyManager.GetPropertyValue(this.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext directoryContext = Utils.GetNewDirectoryContext(dnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, this.context);
adamInstance = new DomainController(directoryContext, dnsHostNameFromNTDSA);
}
directoryServer = adamInstance;
}
else
{
string str = Utils.GetAdamDnsHostNameFromNTDSA(this.context, (string)PropertyManager.GetPropertyValue(this.context, this.schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext newDirectoryContext1 = Utils.GetNewDirectoryContext(str, DirectoryContextType.DirectoryServer, this.context);
directoryServer = new AdamInstance(newDirectoryContext1, str);
}
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException);
}
return directoryServer;
}
private void GetServers()
{
DirectoryServer domainController;
string[] strArrays = new string[1];
strArrays[0] = "dNSHostName";
ADSearcher aDSearcher = new ADSearcher(this.cachedEntry, "(&(objectClass=server)(objectCategory=server))", strArrays, SearchScope.Subtree);
SearchResultCollection searchResultCollections = null;
try
{
searchResultCollections = aDSearcher.FindAll();
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException);
}
try
{
foreach (SearchResult searchResult in searchResultCollections)
{
string searchResultPropertyValue = (string)PropertyManager.GetSearchResultPropertyValue(searchResult, PropertyManager.DnsHostName);
DirectoryEntry directoryEntry = searchResult.GetDirectoryEntry();
DirectoryEntry directoryEntry1 = null;
try
{
directoryEntry1 = directoryEntry.Children.Find("CN=NTDS Settings", "nTDSDSA");
}
catch (COMException cOMException3)
{
COMException cOMException2 = cOMException3;
if (cOMException2.ErrorCode != -2147016656)
{
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException2);
}
else
{
continue;
}
}
if (!this.IsADAM)
{
domainController = new DomainController(Utils.GetNewDirectoryContext(searchResultPropertyValue, DirectoryContextType.DirectoryServer, this.context), searchResultPropertyValue);
}
else
{
int propertyValue = (int)PropertyManager.GetPropertyValue(this.context, directoryEntry1, PropertyManager.MsDSPortLDAP);
string str = searchResultPropertyValue;
if (propertyValue != 0x185)
{
str = string.Concat(searchResultPropertyValue, ":", propertyValue);
}
domainController = new AdamInstance(Utils.GetNewDirectoryContext(str, DirectoryContextType.DirectoryServer, this.context), str);
}
this.servers.Add(domainController);
}
}
finally
{
searchResultCollections.Dispose();
}
}
internal void SyncReplicaHelper(IntPtr dsHandle, bool isADAM, string partition, string sourceServer, int option, LoadLibrarySafeHandle libHandle)
{
Guid ntdsaObjectGuid;
int num = Marshal.SizeOf(typeof(Guid));
AdamInstance adamInstance = null;
DomainController domainController = null;
IntPtr intPtr = Marshal.AllocHGlobal(num);
try
{
if (sourceServer != null)
{
DirectoryContext newDirectoryContext = Utils.GetNewDirectoryContext(sourceServer, DirectoryContextType.DirectoryServer, this.context);
if (!isADAM)
{
domainController = DomainController.GetDomainController(newDirectoryContext);
ntdsaObjectGuid = domainController.NtdsaObjectGuid;
}
else
{
adamInstance = AdamInstance.GetAdamInstance(newDirectoryContext);
ntdsaObjectGuid = adamInstance.NtdsaObjectGuid;
}
Marshal.StructureToPtr(ntdsaObjectGuid, intPtr, false);
}
IntPtr procAddress = UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaSyncW");
if (procAddress != (IntPtr)0)
{
UnsafeNativeMethods.DsReplicaSyncW delegateForFunctionPointer = (UnsafeNativeMethods.DsReplicaSyncW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(UnsafeNativeMethods.DsReplicaSyncW));
int num1 = delegateForFunctionPointer(dsHandle, partition, intPtr, option);
if (num1 != 0)
{
if (this.Partitions.Contains(partition))
{
string name = null;
if (num1 != ExceptionHelper.RPC_S_SERVER_UNAVAILABLE)
{
if (num1 == ExceptionHelper.RPC_S_CALL_FAILED)
{
name = this.Name;
}
}
else
{
name = sourceServer;
}
throw ExceptionHelper.GetExceptionFromErrorCode(num1, name);
}
else
{
throw new ArgumentException(Res.GetString("ServerNotAReplica"), "partition");
}
}
}
else
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
}
finally
{
if (intPtr != (IntPtr)0)
{
Marshal.FreeHGlobal(intPtr);
}
if (adamInstance != null)
{
adamInstance.Dispose();
}
if (domainController != null)
{
domainController.Dispose();
}
}
}
public bool Contains (DomainController domainController)
{
throw new NotImplementedException ();
}
private DirectoryServer GetSchemaRoleOwner()
{
try
{
_schemaEntry.RefreshCache();
if (context.isADAMConfigSet())
{
// ADAM
string adamInstName = Utils.GetAdamDnsHostNameFromNTDSA(context, (string)PropertyManager.GetPropertyValue(context, _schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext adamInstContext = Utils.GetNewDirectoryContext(adamInstName, DirectoryContextType.DirectoryServer, context);
return new AdamInstance(adamInstContext, adamInstName);
}
else
{
// could be AD or adam server
DirectoryServer server = null;
DirectoryEntry rootDSE = directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if (Utils.CheckCapability(rootDSE, Capability.ActiveDirectory))
{
string dcName = Utils.GetDnsHostNameFromNTDSA(context, (string)PropertyManager.GetPropertyValue(context, _schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext dcContext = Utils.GetNewDirectoryContext(dcName, DirectoryContextType.DirectoryServer, context);
server = new DomainController(dcContext, dcName);
}
else
{
// ADAM case again
string adamInstName = Utils.GetAdamDnsHostNameFromNTDSA(context, (string)PropertyManager.GetPropertyValue(context, _schemaEntry, PropertyManager.FsmoRoleOwner));
DirectoryContext adamInstContext = Utils.GetNewDirectoryContext(adamInstName, DirectoryContextType.DirectoryServer, context);
server = new AdamInstance(adamInstContext, adamInstName);
}
return server;
}
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
}
public void CopyTo (DomainController[] domainControllers, int index)
{
throw new NotImplementedException ();
}
private DirectoryServer FindDirectoryServerInternal(string siteName, bool forceRediscovery)
{
DirectoryServer directoryServer = null;
LocatorOptions flag = 0;
int errorCode = 0;
DomainControllerInfo domainControllerInfo;
if (siteName != null && siteName.Length == 0)
{
throw new ArgumentException(Res.GetString(Res.EmptyStringParameter), "siteName");
}
// Check that the application partition has been committed
if (!_committed)
{
throw new InvalidOperationException(Res.GetString(Res.CannotPerformOperationOnUncommittedObject));
}
// set the force rediscovery flag if required
if (forceRediscovery)
{
flag = LocatorOptions.ForceRediscovery;
}
// call DsGetDcName
errorCode = Locator.DsGetDcNameWrapper(null, _dnsName, siteName, (long)flag | (long)PrivateLocatorFlags.OnlyLDAPNeeded, out domainControllerInfo);
if (errorCode == NativeMethods.ERROR_NO_SUCH_DOMAIN)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString(Res.ReplicaNotFound), typeof(DirectoryServer), null);
}
else if (errorCode != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
Debug.Assert(domainControllerInfo.DomainControllerName.Length > 2, "ApplicationPartition:FindDirectoryServerInternal - domainControllerInfo.DomainControllerName.Length <= 2");
string dcName = domainControllerInfo.DomainControllerName.Substring(2);
// create a new context object for the domain controller passing on only the
// credentials from the forest context
DirectoryContext dcContext = Utils.GetNewDirectoryContext(dcName, DirectoryContextType.DirectoryServer, context);
directoryServer = new DomainController(dcContext, dcName);
return directoryServer;
}
internal void SyncReplicaHelper(IntPtr dsHandle, bool isADAM, string partition, string sourceServer, int option, LoadLibrarySafeHandle libHandle)
{
int structSize = Marshal.SizeOf(typeof(Guid));
IntPtr unmanagedGuid = (IntPtr)0;
Guid guid = Guid.Empty;
AdamInstance adamServer = null;
DomainController dcServer = null;
unmanagedGuid = Marshal.AllocHGlobal(structSize);
try
{
if (sourceServer != null)
{
DirectoryContext newContext = Utils.GetNewDirectoryContext(sourceServer, DirectoryContextType.DirectoryServer, context);
if (isADAM)
{
adamServer = AdamInstance.GetAdamInstance(newContext);
guid = adamServer.NtdsaObjectGuid;
}
else
{
dcServer = DomainController.GetDomainController(newContext);
guid = dcServer.NtdsaObjectGuid;
}
Marshal.StructureToPtr(guid, unmanagedGuid, false);
}
// call DsReplicaSyncW
IntPtr functionPtr = UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaSyncW");
if (functionPtr == (IntPtr)0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
UnsafeNativeMethods.DsReplicaSyncW dsReplicaSyncW = (UnsafeNativeMethods.DsReplicaSyncW)Marshal.GetDelegateForFunctionPointer(functionPtr, typeof(UnsafeNativeMethods.DsReplicaSyncW));
int result = dsReplicaSyncW(dsHandle, partition, unmanagedGuid, (int)option);
// check the result
if (result != 0)
{
if (!Partitions.Contains(partition))
{
throw new ArgumentException(SR.ServerNotAReplica, "partition");
}
string serverDownName = null;
// this is the error returned when the server that we want to sync from is down
if (result == ExceptionHelper.RPC_S_SERVER_UNAVAILABLE)
{
serverDownName = sourceServer;
}
// this is the error returned when the server that we want to get synced is down
else if (result == ExceptionHelper.RPC_S_CALL_FAILED)
{
serverDownName = Name;
}
throw ExceptionHelper.GetExceptionFromErrorCode(result, serverDownName);
}
}
finally
{
if (unmanagedGuid != (IntPtr)0)
{
Marshal.FreeHGlobal(unmanagedGuid);
}
if (adamServer != null)
{
adamServer.Dispose();
}
if (dcServer != null)
{
dcServer.Dispose();
}
}
}
internal void SyncReplicaHelper(IntPtr dsHandle, bool isADAM, string partition, string sourceServer, int option, LoadLibrarySafeHandle libHandle)
{
int cb = Marshal.SizeOf(typeof(Guid));
IntPtr zero = IntPtr.Zero;
Guid empty = Guid.Empty;
AdamInstance adamInstance = null;
DomainController domainController = null;
zero = Marshal.AllocHGlobal(cb);
try
{
if (sourceServer != null)
{
DirectoryContext context = Utils.GetNewDirectoryContext(sourceServer, DirectoryContextType.DirectoryServer, this.context);
if (isADAM)
{
adamInstance = AdamInstance.GetAdamInstance(context);
empty = adamInstance.NtdsaObjectGuid;
}
else
{
domainController = DomainController.GetDomainController(context);
empty = domainController.NtdsaObjectGuid;
}
Marshal.StructureToPtr(empty, zero, false);
}
IntPtr procAddress = System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.GetProcAddress(libHandle, "DsReplicaSyncW");
if (procAddress == IntPtr.Zero)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastWin32Error());
}
System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaSyncW delegateForFunctionPointer = (System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaSyncW)Marshal.GetDelegateForFunctionPointer(procAddress, typeof(System.DirectoryServices.ActiveDirectory.UnsafeNativeMethods.DsReplicaSyncW));
int errorCode = delegateForFunctionPointer(dsHandle, partition, zero, option);
if (errorCode != 0)
{
if (!this.Partitions.Contains(partition))
{
throw new ArgumentException(Res.GetString("ServerNotAReplica"), "partition");
}
string targetName = null;
if (errorCode == ExceptionHelper.RPC_S_SERVER_UNAVAILABLE)
{
targetName = sourceServer;
}
else if (errorCode == ExceptionHelper.RPC_S_CALL_FAILED)
{
targetName = this.Name;
}
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode, targetName);
}
}
finally
{
if (zero != IntPtr.Zero)
{
Marshal.FreeHGlobal(zero);
}
if (adamInstance != null)
{
adamInstance.Dispose();
}
if (domainController != null)
{
domainController.Dispose();
}
}
}
public void CopyTo(DomainController[] domainControllers, int index)
{
Contract.Requires(domainControllers != null);
}
public int IndexOf(DomainController domainController)
{
throw new NotImplementedException();
}
private void GetPreferredBridgeheadServers(ActiveDirectoryTransportType transport)
{
string dn = "CN=Servers," + PropertyManager.GetPropertyValue(this.context, this.cachedEntry, PropertyManager.DistinguishedName);
string filterValue = null;
if (transport == ActiveDirectoryTransportType.Smtp)
{
filterValue = "CN=SMTP,CN=Inter-Site Transports," + this.siteDN;
}
else
{
filterValue = "CN=IP,CN=Inter-Site Transports," + this.siteDN;
}
DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, dn);
ADSearcher searcher = new ADSearcher(directoryEntry, "(&(objectClass=server)(objectCategory=Server)(bridgeheadTransportList=" + Utils.GetEscapedFilterValue(filterValue) + "))", new string[] { "dNSHostName", "distinguishedName" }, SearchScope.OneLevel);
SearchResultCollection results = null;
try
{
results = searcher.FindAll();
}
catch (COMException exception)
{
throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception);
}
try
{
DirectoryEntry entry2 = null;
foreach (SearchResult result in results)
{
string searchResultPropertyValue = (string) PropertyManager.GetSearchResultPropertyValue(result, PropertyManager.DnsHostName);
DirectoryEntry entry3 = result.GetDirectoryEntry();
DirectoryServer server = null;
try
{
entry2 = entry3.Children.Find("CN=NTDS Settings", "nTDSDSA");
}
catch (COMException exception2)
{
throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception2);
}
if (this.IsADAM)
{
int num = (int) PropertyManager.GetPropertyValue(this.context, entry2, PropertyManager.MsDSPortLDAP);
string adamInstanceName = searchResultPropertyValue;
if (num != 0x185)
{
adamInstanceName = searchResultPropertyValue + ":" + num;
}
server = new AdamInstance(Utils.GetNewDirectoryContext(adamInstanceName, DirectoryContextType.DirectoryServer, this.context), adamInstanceName);
}
else
{
server = new DomainController(Utils.GetNewDirectoryContext(searchResultPropertyValue, DirectoryContextType.DirectoryServer, this.context), searchResultPropertyValue);
}
if (transport == ActiveDirectoryTransportType.Smtp)
{
this.SMTPBridgeheadServers.Add(server);
}
else
{
this.RPCBridgeheadServers.Add(server);
}
}
}
finally
{
directoryEntry.Dispose();
results.Dispose();
}
}
internal unsafe void SyncReplicaHelper(IntPtr dsHandle, bool isADAM, string partition, string?sourceServer, int option, SafeLibraryHandle libHandle)
{
int structSize = Marshal.SizeOf(typeof(Guid));
IntPtr unmanagedGuid = (IntPtr)0;
Guid guid = Guid.Empty;
AdamInstance? adamServer = null;
DomainController?dcServer = null;
unmanagedGuid = Marshal.AllocHGlobal(structSize);
try
{
if (sourceServer != null)
{
DirectoryContext newContext = Utils.GetNewDirectoryContext(sourceServer, DirectoryContextType.DirectoryServer, context);
if (isADAM)
{
adamServer = AdamInstance.GetAdamInstance(newContext);
guid = adamServer.NtdsaObjectGuid;
}
else
{
dcServer = DomainController.GetDomainController(newContext);
guid = dcServer.NtdsaObjectGuid;
}
Marshal.StructureToPtr(guid, unmanagedGuid, false);
}
// call DsReplicaSyncW
var dsReplicaSyncW = (delegate * unmanaged <IntPtr, char *, IntPtr, int, int>)global::Interop.Kernel32.GetProcAddress(libHandle, "DsReplicaSyncW");
if (dsReplicaSyncW == null)
{
throw ExceptionHelper.GetExceptionFromErrorCode(Marshal.GetLastPInvokeError());
}
fixed(char *partitionPtr = partition)
{
int result = dsReplicaSyncW(dsHandle, partitionPtr, unmanagedGuid, (int)option);
// check the result
if (result != 0)
{
if (!Partitions.Contains(partition))
{
throw new ArgumentException(SR.ServerNotAReplica, nameof(partition));
}
string?serverDownName = null;
// this is the error returned when the server that we want to sync from is down
if (result == ExceptionHelper.RPC_S_SERVER_UNAVAILABLE)
{
serverDownName = sourceServer;
}
// this is the error returned when the server that we want to get synced is down
else if (result == ExceptionHelper.RPC_S_CALL_FAILED)
{
serverDownName = Name;
}
throw ExceptionHelper.GetExceptionFromErrorCode(result, serverDownName);
}
}
}
finally
{
if (unmanagedGuid != (IntPtr)0)
{
Marshal.FreeHGlobal(unmanagedGuid);
}
adamServer?.Dispose();
dcServer?.Dispose();
}
}
