public ActiveDirectorySiteLink(DirectoryContext context, string siteLinkName, ActiveDirectoryTransportType transport, ActiveDirectorySchedule?schedule)
{
ValidateArgument(context, siteLinkName, transport);
// work with copy of the context
context = new DirectoryContext(context);
this.context = context;
_name = siteLinkName;
_transport = transport;
// bind to the rootdse to get the configurationnamingcontext
DirectoryEntry de;
try
{
de = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
string config = (string)PropertyManager.GetPropertyValue(context, de, PropertyManager.ConfigurationNamingContext) !;
string parentDN;
if (transport == ActiveDirectoryTransportType.Rpc)
{
parentDN = "CN=IP,CN=Inter-Site Transports,CN=Sites," + config;
}
else
{
parentDN = "CN=SMTP,CN=Inter-Site Transports,CN=Sites," + config;
}
de = DirectoryEntryManager.GetDirectoryEntry(context, parentDN);
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
catch (ActiveDirectoryObjectNotFoundException)
{
// this is the case where the context is a config set and we could not find an ADAM instance in that config set
throw new ActiveDirectoryOperationException(SR.Format(SR.ADAMInstanceNotFoundInConfigSet, context.Name));
}
try
{
string rdn = "cn=" + _name;
rdn = Utils.GetEscapedPath(rdn);
cachedEntry = de.Children.Add(rdn, "siteLink");
cachedEntry.Properties["cost"].Value = appDefaultCost;
cachedEntry.Properties["replInterval"].Value = appDefaultInterval;
if (schedule != null)
{
cachedEntry.Properties[nameof(schedule)].Value = schedule.GetUnmanagedSchedule();
}
}
catch (COMException e)
{
if (e.ErrorCode == unchecked ((int)0x80072030))
{
// if it is ADAM and transport type is SMTP, throw NotSupportedException.
DirectoryEntry tmpDE = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
if (Utils.CheckCapability(tmpDE, Capability.ActiveDirectoryApplicationMode) && transport == ActiveDirectoryTransportType.Smtp)
{
throw new NotSupportedException(SR.NotSupportTransportSMTP);
}
}
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
finally
{
de.Dispose();
}
}
internal static AdamInstance FindAnyAdamInstance(DirectoryContext context)
{
if (context.ContextType != DirectoryContextType.ConfigurationSet)
{
// assuming it's an ADAM Instance
// check that it is an ADAM server only (not AD)
DirectoryEntryManager directoryEntryMgr = new DirectoryEntryManager(context);
DirectoryEntry rootDSE = directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if (!Utils.CheckCapability(rootDSE, Capability.ActiveDirectoryApplicationMode))
{
directoryEntryMgr.RemoveIfExists(directoryEntryMgr.ExpandWellKnownDN(WellKnownDN.RootDSE));
throw new ArgumentException(SR.TargetShouldBeServerORConfigSet, nameof(context));
}
string dnsHostName = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.DnsHostName);
return(new AdamInstance(context, dnsHostName, directoryEntryMgr));
}
// Now this is the case where context is a Config Set
// Here we need to search for the service connection points in the forest
// (if the forest object was created by specifying the server, we stick to that, else search in a GC)
DirectoryEntry rootEntry = GetSearchRootEntry(Forest.GetCurrentForest());
ArrayList adamInstanceNames = new ArrayList();
try
{
string entryName = (string)rootEntry.Properties["distinguishedName"].Value;
// Search for computer "serviceConnectionObjects" where the keywords attribute
// contains the specified keyword
// set up the searcher object
// build the filter
StringBuilder str = new StringBuilder(15);
str.Append("(&(");
str.Append(PropertyManager.ObjectCategory);
str.Append("=serviceConnectionPoint)");
str.Append('(');
str.Append(PropertyManager.Keywords);
str.Append("=1.2.840.113556.1.4.1851)(");
str.Append(PropertyManager.Keywords);
str.Append('=');
str.Append(Utils.GetEscapedFilterValue(context.Name)); // target = config set name
str.Append("))");
string filter = str.ToString();
string[] propertiesToLoad = new string[1];
propertiesToLoad[0] = PropertyManager.ServiceBindingInformation;
ADSearcher searcher = new ADSearcher(rootEntry, filter, propertiesToLoad, SearchScope.Subtree, false /*not paged search*/, false /*no cached results*/);
SearchResultCollection resCol = searcher.FindAll();
try
{
foreach (SearchResult res in resCol)
{
// the binding info contains two values
// "ldap://hostname:ldapport"
// and "ldaps://hostname:sslport"
// we need the "hostname:ldapport" value
string prefix = "ldap://";
foreach (string bindingInfo in res.Properties[PropertyManager.ServiceBindingInformation])
{
if ((bindingInfo.Length > prefix.Length) && (string.Equals(bindingInfo.Substring(0, prefix.Length), prefix, StringComparison.OrdinalIgnoreCase)))
{
adamInstanceNames.Add(bindingInfo.Substring(prefix.Length));
}
}
}
}
finally
{
resCol.Dispose();
}
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
finally
{
rootEntry.Dispose();
}
//
// we have all the adam instance names in teh form of server:port from the scp
// now we need to find one that is alive
//
return(FindAliveAdamInstance(null, context, adamInstanceNames));
}
private AdamInstance GetRoleOwner(AdamRole role)
{
DirectoryEntry cachedDirectoryEntry = null;
string adamDnsHostNameFromNTDSA = null;
using (cachedDirectoryEntry)
{
try
{
AdamRole adamRole = role;
switch (adamRole)
{
case AdamRole.SchemaRole:
{
cachedDirectoryEntry = this.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.SchemaNamingContext);
break;
}
case AdamRole.NamingRole:
{
cachedDirectoryEntry = this.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.PartitionsContainer);
break;
}
}
cachedDirectoryEntry.RefreshCache();
adamDnsHostNameFromNTDSA = Utils.GetAdamDnsHostNameFromNTDSA(this.context, (string)PropertyManager.GetPropertyValue(this.context, cachedDirectoryEntry, PropertyManager.FsmoRoleOwner));
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException);
}
}
DirectoryContext newDirectoryContext = Utils.GetNewDirectoryContext(adamDnsHostNameFromNTDSA, DirectoryContextType.DirectoryServer, this.context);
return(new AdamInstance(newDirectoryContext, adamDnsHostNameFromNTDSA));
}
public ReplicationConnection(DirectoryContext context, string name, DirectoryServer sourceServer, ActiveDirectorySchedule schedule, ActiveDirectoryTransportType transport)
{
ValidateArgument(context, name);
if (sourceServer == null)
{
throw new ArgumentNullException("sourceServer");
}
if ((transport < ActiveDirectoryTransportType.Rpc) || (transport > ActiveDirectoryTransportType.Smtp))
{
throw new InvalidEnumArgumentException("value", (int)transport, typeof(ActiveDirectoryTransportType));
}
context = new DirectoryContext(context);
this.ValidateTargetAndSourceServer(context, sourceServer);
this.context = context;
this.connectionName = name;
this.transport = transport;
DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
try
{
string str = (string)PropertyManager.GetPropertyValue(context, directoryEntry, PropertyManager.ServerName);
string dn = "CN=NTDS Settings," + str;
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, dn);
string escapedPath = Utils.GetEscapedPath("cn=" + this.connectionName);
this.cachedDirectoryEntry = directoryEntry.Children.Add(escapedPath, "nTDSConnection");
DirectoryContext context2 = sourceServer.Context;
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context2, WellKnownDN.RootDSE);
string str4 = (string)PropertyManager.GetPropertyValue(context2, directoryEntry, PropertyManager.ServerName);
str4 = "CN=NTDS Settings," + str4;
this.cachedDirectoryEntry.Properties["fromServer"].Add(str4);
if (schedule != null)
{
this.cachedDirectoryEntry.Properties["schedule"].Value = schedule.GetUnmanagedSchedule();
}
string dNFromTransportType = Utils.GetDNFromTransportType(this.TransportType, context);
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, dNFromTransportType);
try
{
directoryEntry.Bind(true);
}
catch (COMException exception)
{
if (((exception.ErrorCode == -2147016656) && Utils.CheckCapability(DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE), Capability.ActiveDirectoryApplicationMode)) && (transport == ActiveDirectoryTransportType.Smtp))
{
throw new NotSupportedException(Res.GetString("NotSupportTransportSMTP"));
}
throw ExceptionHelper.GetExceptionFromCOMException(context, exception);
}
this.cachedDirectoryEntry.Properties["transportType"].Add(dNFromTransportType);
this.cachedDirectoryEntry.Properties["enabledConnection"].Value = false;
this.cachedDirectoryEntry.Properties["options"].Value = 0;
}
catch (COMException exception2)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, exception2);
}
finally
{
directoryEntry.Close();
}
}
public void MoveToAnotherSite(string siteName)
{
CheckIfDisposed();
// validate siteName
if (siteName == null)
{
throw new ArgumentNullException(nameof(siteName));
}
if (siteName.Length == 0)
{
throw new ArgumentException(SR.EmptyStringParameter, nameof(siteName));
}
// the dc is really being moved to a different site
if (Utils.Compare(SiteName, siteName) != 0)
{
DirectoryEntry?newParentEntry = null;
try
{
// Bind to the target site's server container
// Get the distinguished name for the site
string parentDN = "CN=Servers,CN=" + siteName + "," + directoryEntryMgr.ExpandWellKnownDN(WellKnownDN.SitesContainer);
newParentEntry = DirectoryEntryManager.GetDirectoryEntry(context, parentDN);
string serverName = (this is DomainController) ? ((DomainController)this).ServerObjectName : ((AdamInstance)this).ServerObjectName;
DirectoryEntry serverEntry = directoryEntryMgr.GetCachedDirectoryEntry(serverName);
// force binding (needed otherwise S.DS throw an exception while releasing the COM interface pointer)
_ = (string?)PropertyManager.GetPropertyValue(context, serverEntry, PropertyManager.DistinguishedName);
// move the object to the servers container of the target site
serverEntry.MoveTo(newParentEntry);
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
finally
{
if (newParentEntry != null)
{
newParentEntry.Dispose();
}
}
// remove stale cached directory entries
// invalidate the cached properties that get affected by this
siteInfoModified = true;
cachedSiteName = null;
if (cachedSiteObjectName != null)
{
directoryEntryMgr.RemoveIfExists(cachedSiteObjectName);
cachedSiteObjectName = null;
}
if (cachedServerObjectName != null)
{
directoryEntryMgr.RemoveIfExists(cachedServerObjectName);
cachedServerObjectName = null;
}
if (cachedNtdsaObjectName != null)
{
directoryEntryMgr.RemoveIfExists(cachedNtdsaObjectName);
cachedNtdsaObjectName = null;
}
}
}
internal static AdamInstance FindAnyAdamInstance(DirectoryContext context)
{
if (context.ContextType == DirectoryContextType.ConfigurationSet)
{
DirectoryEntry searchRootEntry = ConfigurationSet.GetSearchRootEntry(Forest.GetCurrentForest());
ArrayList arrayLists = new ArrayList();
try
{
try
{
StringBuilder stringBuilder = new StringBuilder(15);
stringBuilder.Append("(&(");
stringBuilder.Append(PropertyManager.ObjectCategory);
stringBuilder.Append("=serviceConnectionPoint)");
stringBuilder.Append("(");
stringBuilder.Append(PropertyManager.Keywords);
stringBuilder.Append("=1.2.840.113556.1.4.1851)(");
stringBuilder.Append(PropertyManager.Keywords);
stringBuilder.Append("=");
stringBuilder.Append(Utils.GetEscapedFilterValue(context.Name));
stringBuilder.Append("))");
string str = stringBuilder.ToString();
string[] serviceBindingInformation = new string[1];
serviceBindingInformation[0] = PropertyManager.ServiceBindingInformation;
ADSearcher aDSearcher = new ADSearcher(searchRootEntry, str, serviceBindingInformation, SearchScope.Subtree, false, false);
SearchResultCollection searchResultCollections = aDSearcher.FindAll();
try
{
foreach (SearchResult item in searchResultCollections)
{
string str1 = "ldap://";
IEnumerator enumerator = item.Properties[PropertyManager.ServiceBindingInformation].GetEnumerator();
try
{
while (enumerator.MoveNext())
{
string str2 = item.ToString();
if (str2.Length <= str1.Length || string.Compare(str2.Substring(0, str1.Length), str1, StringComparison.OrdinalIgnoreCase) != 0)
{
continue;
}
arrayLists.Add(str2.Substring(str1.Length));
}
}
finally
{
IDisposable disposable = enumerator as IDisposable;
if (disposable != null)
{
disposable.Dispose();
}
}
}
}
finally
{
searchResultCollections.Dispose();
}
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException);
}
}
finally
{
searchRootEntry.Dispose();
}
return(ConfigurationSet.FindAliveAdamInstance(null, context, arrayLists));
}
else
{
DirectoryEntryManager directoryEntryManager = new DirectoryEntryManager(context);
DirectoryEntry cachedDirectoryEntry = directoryEntryManager.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if (Utils.CheckCapability(cachedDirectoryEntry, Capability.ActiveDirectoryApplicationMode))
{
string propertyValue = (string)PropertyManager.GetPropertyValue(context, cachedDirectoryEntry, PropertyManager.DnsHostName);
return(new AdamInstance(context, propertyValue, directoryEntryManager));
}
else
{
directoryEntryManager.RemoveIfExists(directoryEntryManager.ExpandWellKnownDN(WellKnownDN.RootDSE));
throw new ArgumentException(Res.GetString("TargetShouldBeServerORConfigSet"), "context");
}
}
}
public static ActiveDirectoryInterSiteTransport FindByTransportType(DirectoryContext context, ActiveDirectoryTransportType transport)
{
DirectoryEntry directoryEntry;
if (context != null)
{
if (context.Name != null || context.isRootDomain())
{
if (context.Name == null || context.isRootDomain() || context.isServer() || context.isADAMConfigSet())
{
if (transport < ActiveDirectoryTransportType.Rpc || transport > ActiveDirectoryTransportType.Smtp)
{
throw new InvalidEnumArgumentException("value", (int)transport, typeof(ActiveDirectoryTransportType));
}
else
{
context = new DirectoryContext(context);
try
{
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
string propertyValue = (string)PropertyManager.GetPropertyValue(context, directoryEntry, PropertyManager.ConfigurationNamingContext);
string str = string.Concat("CN=Inter-Site Transports,CN=Sites,", propertyValue);
if (transport != ActiveDirectoryTransportType.Rpc)
{
str = string.Concat("CN=SMTP,", str);
}
else
{
str = string.Concat("CN=IP,", str);
}
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, str);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException);
}
catch (ActiveDirectoryObjectNotFoundException activeDirectoryObjectNotFoundException)
{
object[] name = new object[1];
name[0] = context.Name;
throw new ActiveDirectoryOperationException(Res.GetString("ADAMInstanceNotFoundInConfigSet", name));
}
try
{
string[] strArrays = new string[1];
strArrays[0] = "options";
directoryEntry.RefreshCache(strArrays);
}
catch (COMException cOMException3)
{
COMException cOMException2 = cOMException3;
if (cOMException2.ErrorCode != -2147016656)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException2);
}
else
{
DirectoryEntry directoryEntry1 = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
if (!Utils.CheckCapability(directoryEntry1, Capability.ActiveDirectoryApplicationMode) || transport != ActiveDirectoryTransportType.Smtp)
{
object[] objArray = new object[1];
objArray[0] = transport.ToString();
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("TransportNotFound", objArray), typeof(ActiveDirectoryInterSiteTransport), transport.ToString());
}
else
{
throw new NotSupportedException(Res.GetString("NotSupportTransportSMTP"));
}
}
}
return(new ActiveDirectoryInterSiteTransport(context, transport, directoryEntry));
}
}
else
{
throw new ArgumentException(Res.GetString("NotADOrADAM"), "context");
}
}
else
{
throw new ArgumentException(Res.GetString("ContextNotAssociatedWithDomain"), "context");
}
}
else
{
throw new ArgumentNullException("context");
}
}
public static ActiveDirectorySchema GetSchema(DirectoryContext context)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
if (((context.ContextType != DirectoryContextType.Forest) && (context.ContextType != DirectoryContextType.ConfigurationSet)) && (context.ContextType != DirectoryContextType.DirectoryServer))
{
throw new ArgumentException(Res.GetString("NotADOrADAM"), "context");
}
if ((context.Name == null) && !context.isRootDomain())
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ContextNotAssociatedWithDomain"), typeof(ActiveDirectorySchema), null);
}
if (((context.Name != null) && !context.isRootDomain()) && (!context.isADAMConfigSet() && !context.isServer()))
{
if (context.ContextType == DirectoryContextType.Forest)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ForestNotFound"), typeof(ActiveDirectorySchema), context.Name);
}
if (context.ContextType == DirectoryContextType.ConfigurationSet)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ConfigSetNotFound"), typeof(ActiveDirectorySchema), context.Name);
}
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ServerNotFound", new object[] { context.Name }), typeof(ActiveDirectorySchema), null);
}
context = new DirectoryContext(context);
DirectoryEntryManager directoryEntryMgr = new DirectoryEntryManager(context);
string distinguishedName = null;
try
{
DirectoryEntry cachedDirectoryEntry = directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if (context.isServer() && !Utils.CheckCapability(cachedDirectoryEntry, Capability.ActiveDirectoryOrADAM))
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ServerNotFound", new object[] { context.Name }), typeof(ActiveDirectorySchema), null);
}
distinguishedName = (string)PropertyManager.GetPropertyValue(context, cachedDirectoryEntry, PropertyManager.SchemaNamingContext);
}
catch (COMException exception)
{
if (exception.ErrorCode != -2147016646)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, exception);
}
if (context.ContextType == DirectoryContextType.Forest)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ForestNotFound"), typeof(ActiveDirectorySchema), context.Name);
}
if (context.ContextType == DirectoryContextType.ConfigurationSet)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ConfigSetNotFound"), typeof(ActiveDirectorySchema), context.Name);
}
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ServerNotFound", new object[] { context.Name }), typeof(ActiveDirectorySchema), null);
}
catch (ActiveDirectoryObjectNotFoundException)
{
if (context.ContextType == DirectoryContextType.ConfigurationSet)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ConfigSetNotFound"), typeof(ActiveDirectorySchema), context.Name);
}
throw;
}
return(new ActiveDirectorySchema(context, distinguishedName, directoryEntryMgr));
}
private void ValidateTargetAndSourceServer(DirectoryContext context, DirectoryServer sourceServer)
{
bool targetIsDC = false;
DirectoryEntry targetDE = null;
DirectoryEntry sourceDE = null;
// first find out target is a dc or ADAM instance
targetDE = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
try
{
if (Utils.CheckCapability(targetDE, Capability.ActiveDirectory))
{
targetIsDC = true;
}
else if (!Utils.CheckCapability(targetDE, Capability.ActiveDirectoryApplicationMode))
{
// if it is also not an ADAM instance, it is invalid then
throw new ArgumentException(Res.GetString(Res.DirectoryContextNeedHost), "context");
}
if (targetIsDC && !(sourceServer is DomainController))
{
// target and sourceServer are not of the same type
throw new ArgumentException(Res.GetString(Res.ConnectionSourcServerShouldBeDC), "sourceServer");
}
else if (!targetIsDC && (sourceServer is DomainController))
{
// target and sourceServer are not of the same type
throw new ArgumentException(Res.GetString(Res.ConnectionSourcServerShouldBeADAM), "sourceServer");
}
sourceDE = DirectoryEntryManager.GetDirectoryEntry(sourceServer.Context, WellKnownDN.RootDSE);
// now if they are both dc, we need to check whether they come from the same forest
if (targetIsDC)
{
string targetRoot = (string)PropertyManager.GetPropertyValue(context, targetDE, PropertyManager.RootDomainNamingContext);
string sourceRoot = (string)PropertyManager.GetPropertyValue(sourceServer.Context, sourceDE, PropertyManager.RootDomainNamingContext);
if (Utils.Compare(targetRoot, sourceRoot) != 0)
{
throw new ArgumentException(Res.GetString(Res.ConnectionSourcServerSameForest), "sourceServer");
}
}
else
{
string targetRoot = (string)PropertyManager.GetPropertyValue(context, targetDE, PropertyManager.ConfigurationNamingContext);
string sourceRoot = (string)PropertyManager.GetPropertyValue(sourceServer.Context, sourceDE, PropertyManager.ConfigurationNamingContext);
if (Utils.Compare(targetRoot, sourceRoot) != 0)
{
throw new ArgumentException(Res.GetString(Res.ConnectionSourcServerSameConfigSet), "sourceServer");
}
}
}
catch (COMException e)
{
ExceptionHelper.GetExceptionFromCOMException(context, e);
}
finally
{
if (targetDE != null)
{
targetDE.Close();
}
if (sourceDE != null)
{
sourceDE.Close();
}
}
}
public ReplicationConnection(DirectoryContext context, string name, DirectoryServer sourceServer, ActiveDirectorySchedule schedule, ActiveDirectoryTransportType transport)
{
ValidateArgument(context, name);
if (sourceServer == null)
{
throw new ArgumentNullException("sourceServer");
}
if (transport < ActiveDirectoryTransportType.Rpc || transport > ActiveDirectoryTransportType.Smtp)
{
throw new InvalidEnumArgumentException("value", (int)transport, typeof(ActiveDirectoryTransportType));
}
// work with copy of the context
context = new DirectoryContext(context);
ValidateTargetAndSourceServer(context, sourceServer);
this.context = context;
_connectionName = name;
_transport = transport;
DirectoryEntry de = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
try
{
string serverDN = (string)PropertyManager.GetPropertyValue(context, de, PropertyManager.ServerName);
string connectionContainer = "CN=NTDS Settings," + serverDN;
de = DirectoryEntryManager.GetDirectoryEntry(context, connectionContainer);
// create the connection entry
string rdn = "cn=" + _connectionName;
rdn = Utils.GetEscapedPath(rdn);
cachedDirectoryEntry = de.Children.Add(rdn, "nTDSConnection");
// set all the properties
// sourceserver property
DirectoryContext sourceServerContext = sourceServer.Context;
de = DirectoryEntryManager.GetDirectoryEntry(sourceServerContext, WellKnownDN.RootDSE);
string serverName = (string)PropertyManager.GetPropertyValue(sourceServerContext, de, PropertyManager.ServerName);
serverName = "CN=NTDS Settings," + serverName;
cachedDirectoryEntry.Properties["fromServer"].Add(serverName);
// schedule property
if (schedule != null)
{
cachedDirectoryEntry.Properties["schedule"].Value = schedule.GetUnmanagedSchedule();
}
// transporttype property
string transportPath = Utils.GetDNFromTransportType(TransportType, context);
// verify that the transport is supported
de = DirectoryEntryManager.GetDirectoryEntry(context, transportPath);
try
{
de.Bind(true);
}
catch (COMException e)
{
if (e.ErrorCode == unchecked ((int)0x80072030))
{
// if it is ADAM and transport type is SMTP, throw NotSupportedException.
DirectoryEntry tmpDE = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
if (Utils.CheckCapability(tmpDE, Capability.ActiveDirectoryApplicationMode) && transport == ActiveDirectoryTransportType.Smtp)
{
throw new NotSupportedException(Res.GetString(Res.NotSupportTransportSMTP));
}
}
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
cachedDirectoryEntry.Properties["transportType"].Add(transportPath);
// enabledConnection property
cachedDirectoryEntry.Properties["enabledConnection"].Value = false;
// options
cachedDirectoryEntry.Properties["options"].Value = 0;
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
finally
{
de.Close();
}
}
public static Forest GetForest(DirectoryContext context)
{
DirectoryEntryManager?directoryEntryMgr = null;
DirectoryEntry? rootDSE = null;
string?rootDomainNC = null;
// check that the argument is not null
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// contexttype should be Forest or DirectoryServer
if ((context.ContextType != DirectoryContextType.Forest) &&
(context.ContextType != DirectoryContextType.DirectoryServer))
{
throw new ArgumentException(SR.TargetShouldBeServerORForest, nameof(context));
}
if ((context.Name == null) && (!context.isRootDomain()))
{
throw new ActiveDirectoryObjectNotFoundException(SR.ContextNotAssociatedWithDomain, typeof(Forest), null);
}
if (context.Name != null)
{
// the target should be a valid forest name or a server
if (!((context.isRootDomain()) || (context.isServer())))
{
if (context.ContextType == DirectoryContextType.Forest)
{
throw new ActiveDirectoryObjectNotFoundException(SR.ForestNotFound, typeof(Forest), context.Name);
}
else
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.DCNotFound, context.Name), typeof(Forest), null);
}
}
}
// work with copy of the context
context = new DirectoryContext(context);
directoryEntryMgr = new DirectoryEntryManager(context);
// at this point we know that the target is either a
// valid forest name or a server (may be a bogus server name -- to check bind to rootdse)
// bind to the rootDSE of the forest specified in the context
try
{
rootDSE = directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if ((context.isServer()) && (!Utils.CheckCapability(rootDSE, Capability.ActiveDirectory)))
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.DCNotFound, context.Name), typeof(Forest), null);
}
rootDomainNC = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.RootDomainNamingContext) !;
}
catch (COMException e)
{
int errorCode = e.ErrorCode;
if (errorCode == unchecked ((int)0x8007203a))
{
if (context.ContextType == DirectoryContextType.Forest)
{
throw new ActiveDirectoryObjectNotFoundException(SR.ForestNotFound, typeof(Forest), context.Name);
}
else
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.DCNotFound, context.Name), typeof(Forest), null);
}
}
else
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
}
// return forest object
return(new Forest(context, Utils.GetDnsNameFromDN(rootDomainNC), directoryEntryMgr));
}
public void Save()
{
base.CheckIfDisposed();
if (this.committed)
{
goto Label_021F;
}
bool flag = false;
if (this.appType == ApplicationPartitionType.ADApplicationPartition)
{
try
{
this.domainDNSEntry.CommitChanges();
goto Label_004B;
}
catch (COMException exception)
{
if (exception.ErrorCode != -2147016663)
{
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception);
}
flag = true;
goto Label_004B;
}
}
flag = true;
Label_004B:
if (flag)
{
try
{
this.InitializeCrossRef(base.partitionName);
this.crossRefEntry.CommitChanges();
}
catch (COMException exception2)
{
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception2);
}
try
{
this.domainDNSEntry.CommitChanges();
}
catch (COMException exception3)
{
DirectoryEntry parent = this.crossRefEntry.Parent;
try
{
parent.Children.Remove(this.crossRefEntry);
}
catch (COMException exception4)
{
throw ExceptionHelper.GetExceptionFromCOMException(exception4);
}
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception3);
}
try
{
this.crossRefEntry.RefreshCache();
}
catch (COMException exception5)
{
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception5);
}
}
DirectoryEntry cachedDirectoryEntry = base.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
string str = (string)PropertyManager.GetPropertyValue(base.context, cachedDirectoryEntry, PropertyManager.DsServiceName);
if (this.appType == ApplicationPartitionType.ADApplicationPartition)
{
this.GetCrossRefEntry();
}
string str2 = (string)PropertyManager.GetPropertyValue(base.context, this.crossRefEntry, PropertyManager.DistinguishedName);
DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(Utils.GetNewDirectoryContext(this.GetNamingRoleOwner(), DirectoryContextType.DirectoryServer, base.context), WellKnownDN.RootDSE);
try
{
directoryEntry.Properties[PropertyManager.ReplicateSingleObject].Value = str + ":" + str2;
directoryEntry.CommitChanges();
}
catch (COMException exception6)
{
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception6);
}
finally
{
directoryEntry.Dispose();
}
this.committed = true;
if ((this.cachedDirectoryServers == null) && !this.securityRefDomainModified)
{
goto Label_024C;
}
if (this.cachedDirectoryServers != null)
{
this.crossRefEntry.Properties[PropertyManager.MsDSNCReplicaLocations].AddRange(this.cachedDirectoryServers.GetMultiValuedProperty());
}
if (this.securityRefDomainModified)
{
this.crossRefEntry.Properties[PropertyManager.MsDSSDReferenceDomain].Value = this.securityRefDomain;
}
try
{
this.crossRefEntry.CommitChanges();
goto Label_024C;
}
catch (COMException exception7)
{
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception7);
}
Label_021F:
if ((this.cachedDirectoryServers != null) || this.securityRefDomainModified)
{
try
{
this.crossRefEntry.CommitChanges();
}
catch (COMException exception8)
{
throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception8);
}
}
Label_024C:
this.cachedDirectoryServers = null;
this.securityRefDomainModified = false;
}
public static ApplicationPartition FindByName(DirectoryContext context, string distinguishedName)
{
DirectoryEntryManager directoryEntryMgr = null;
DirectoryContext context2 = null;
if (context == null)
{
throw new ArgumentNullException("context");
}
if ((context.Name == null) && !context.isRootDomain())
{
throw new ArgumentException(Res.GetString("ContextNotAssociatedWithDomain"), "context");
}
if (((context.Name != null) && !context.isRootDomain()) && (!context.isADAMConfigSet() && !context.isServer()))
{
throw new ArgumentException(Res.GetString("NotADOrADAM"), "context");
}
if (distinguishedName == null)
{
throw new ArgumentNullException("distinguishedName");
}
if (distinguishedName.Length == 0)
{
throw new ArgumentException(Res.GetString("EmptyStringParameter"), "distinguishedName");
}
if (!Utils.IsValidDNFormat(distinguishedName))
{
throw new ArgumentException(Res.GetString("InvalidDNFormat"), "distinguishedName");
}
context = new DirectoryContext(context);
directoryEntryMgr = new DirectoryEntryManager(context);
DirectoryEntry searchRoot = null;
try
{
searchRoot = DirectoryEntryManager.GetDirectoryEntry(context, directoryEntryMgr.ExpandWellKnownDN(WellKnownDN.PartitionsContainer));
}
catch (COMException exception)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, exception);
}
catch (ActiveDirectoryObjectNotFoundException)
{
throw new ActiveDirectoryOperationException(Res.GetString("ADAMInstanceNotFoundInConfigSet", new object[] { context.Name }));
}
StringBuilder builder = new StringBuilder(15);
builder.Append("(&(");
builder.Append(PropertyManager.ObjectCategory);
builder.Append("=crossRef)(");
builder.Append(PropertyManager.SystemFlags);
builder.Append(":1.2.840.113556.1.4.804:=");
builder.Append(1);
builder.Append(")(!(");
builder.Append(PropertyManager.SystemFlags);
builder.Append(":1.2.840.113556.1.4.803:=");
builder.Append(2);
builder.Append("))(");
builder.Append(PropertyManager.NCName);
builder.Append("=");
builder.Append(Utils.GetEscapedFilterValue(distinguishedName));
builder.Append("))");
string filter = builder.ToString();
string[] propertiesToLoad = new string[] { PropertyManager.DnsRoot, PropertyManager.NCName };
ADSearcher searcher = new ADSearcher(searchRoot, filter, propertiesToLoad, SearchScope.OneLevel, false, false);
SearchResult res = null;
try
{
res = searcher.FindOne();
}
catch (COMException exception2)
{
if (exception2.ErrorCode == -2147016656)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AppNCNotFound"), typeof(ApplicationPartition), distinguishedName);
}
throw ExceptionHelper.GetExceptionFromCOMException(context, exception2);
}
finally
{
searchRoot.Dispose();
}
if (res == null)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AppNCNotFound"), typeof(ApplicationPartition), distinguishedName);
}
string domainName = null;
try
{
domainName = (res.Properties[PropertyManager.DnsRoot].Count > 0) ? ((string)res.Properties[PropertyManager.DnsRoot][0]) : null;
}
catch (COMException exception3)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, exception3);
}
ApplicationPartitionType applicationPartitionType = GetApplicationPartitionType(context);
if (context.ContextType != DirectoryContextType.DirectoryServer)
{
if (applicationPartitionType == ApplicationPartitionType.ADApplicationPartition)
{
DomainControllerInfo info;
int errorCode = 0;
errorCode = Locator.DsGetDcNameWrapper(null, domainName, null, 0x8000L, out info);
if (errorCode == 0x54b)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AppNCNotFound"), typeof(ApplicationPartition), distinguishedName);
}
if (errorCode != 0)
{
throw ExceptionHelper.GetExceptionFromErrorCode(errorCode);
}
context2 = Utils.GetNewDirectoryContext(info.DomainControllerName.Substring(2), DirectoryContextType.DirectoryServer, context);
}
else
{
context2 = Utils.GetNewDirectoryContext(ConfigurationSet.FindOneAdamInstance(context.Name, context, distinguishedName, null).Name, DirectoryContextType.DirectoryServer, context);
}
goto Label_03FC;
}
bool flag = false;
DistinguishedName dn = new DistinguishedName(distinguishedName);
DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
try
{
foreach (string str3 in directoryEntry.Properties[PropertyManager.NamingContexts])
{
DistinguishedName name2 = new DistinguishedName(str3);
if (name2.Equals(dn))
{
flag = true;
goto Label_0352;
}
}
}
catch (COMException exception4)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, exception4);
}
finally
{
directoryEntry.Dispose();
}
Label_0352:
if (!flag)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AppNCNotFound"), typeof(ApplicationPartition), distinguishedName);
}
context2 = context;
Label_03FC:
return(new ApplicationPartition(context2, (string)PropertyManager.GetSearchResultPropertyValue(res, PropertyManager.NCName), domainName, applicationPartitionType, directoryEntryMgr));
}
private ArrayList GetApplicationPartitions()
{
ArrayList appNCs = new ArrayList();
DirectoryEntry rootDSE = _directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
DirectoryEntry partitionsEntry = _directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.PartitionsContainer);
// search for all the "crossRef" objects that have the
// ADS_SYSTEMFLAG_CR_NTDS_NC set and the SYSTEMFLAG_CR_NTDS_DOMAIN flag not set
// (one-level search is good enough)
// setup the directory searcher object
// build the filter
StringBuilder str = new StringBuilder(100);
str.Append("(&(");
str.Append(PropertyManager.ObjectCategory);
str.Append("=crossRef)(");
str.Append(PropertyManager.SystemFlags);
str.Append(":1.2.840.113556.1.4.804:=");
str.Append((int)SystemFlag.SystemFlagNtdsNC);
str.Append(")(!(");
str.Append(PropertyManager.SystemFlags);
str.Append(":1.2.840.113556.1.4.803:=");
str.Append((int)SystemFlag.SystemFlagNtdsDomain);
str.Append(")))");
string filter = str.ToString();
string[] propertiesToLoad = new string[2];
propertiesToLoad[0] = PropertyManager.NCName;
propertiesToLoad[1] = PropertyManager.MsDSNCReplicaLocations;
ADSearcher searcher = new ADSearcher(partitionsEntry, filter, propertiesToLoad, SearchScope.OneLevel);
SearchResultCollection resCol = null;
try
{
resCol = searcher.FindAll();
string schemaNamingContext = (string)PropertyManager.GetPropertyValue(_context, rootDSE, PropertyManager.SchemaNamingContext);
string configurationNamingContext = (string)PropertyManager.GetPropertyValue(_context, rootDSE, PropertyManager.ConfigurationNamingContext);
foreach (SearchResult res in resCol)
{
// add the name of the appNC only if it is not
// the Schema or Configuration partition
string nCName = (string)PropertyManager.GetSearchResultPropertyValue(res, PropertyManager.NCName);
if ((!(nCName.Equals(schemaNamingContext))) && (!(nCName.Equals(configurationNamingContext))))
{
ResultPropertyValueCollection replicaLocations = res.Properties[PropertyManager.MsDSNCReplicaLocations];
if (replicaLocations.Count > 0)
{
string replicaName = Utils.GetAdamDnsHostNameFromNTDSA(_context, (string)replicaLocations[Utils.GetRandomIndex(replicaLocations.Count)]);
DirectoryContext appNCContext = Utils.GetNewDirectoryContext(replicaName, DirectoryContextType.DirectoryServer, _context);
appNCs.Add(new ApplicationPartition(appNCContext, nCName, null, ApplicationPartitionType.ADAMApplicationPartition, new DirectoryEntryManager(appNCContext)));
}
}
}
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(_context, e);
}
finally
{
if (resCol != null)
{
// call dispose on search result collection
resCol.Dispose();
}
}
return(appNCs);
}
public static ActiveDirectorySiteLinkBridge FindByName(DirectoryContext context, string bridgeName, ActiveDirectoryTransportType transport)
{
DirectoryEntry directoryEntry;
ActiveDirectorySiteLinkBridge activeDirectorySiteLinkBridge;
ActiveDirectorySiteLinkBridge.ValidateArgument(context, bridgeName, transport);
context = new DirectoryContext(context);
try
{
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
string propertyValue = (string)PropertyManager.GetPropertyValue(context, directoryEntry, PropertyManager.ConfigurationNamingContext);
string str = string.Concat("CN=Inter-Site Transports,CN=Sites,", propertyValue);
if (transport != ActiveDirectoryTransportType.Rpc)
{
str = string.Concat("CN=SMTP,", str);
}
else
{
str = string.Concat("CN=IP,", str);
}
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, str);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException);
}
catch (ActiveDirectoryObjectNotFoundException activeDirectoryObjectNotFoundException)
{
object[] name = new object[1];
name[0] = context.Name;
throw new ActiveDirectoryOperationException(Res.GetString("ADAMInstanceNotFoundInConfigSet", name));
}
try
{
try
{
string[] strArrays = new string[1];
strArrays[0] = "distinguishedName";
ADSearcher aDSearcher = new ADSearcher(directoryEntry, string.Concat("(&(objectClass=siteLinkBridge)(objectCategory=SiteLinkBridge)(name=", Utils.GetEscapedFilterValue(bridgeName), "))"), strArrays, SearchScope.OneLevel, false, false);
SearchResult searchResult = aDSearcher.FindOne();
if (searchResult != null)
{
DirectoryEntry directoryEntry1 = searchResult.GetDirectoryEntry();
ActiveDirectorySiteLinkBridge activeDirectorySiteLinkBridge1 = new ActiveDirectorySiteLinkBridge(context, bridgeName, transport, true);
activeDirectorySiteLinkBridge1.cachedEntry = directoryEntry1;
activeDirectorySiteLinkBridge = activeDirectorySiteLinkBridge1;
}
else
{
Exception exception = new ActiveDirectoryObjectNotFoundException(Res.GetString("DSNotFound"), typeof(ActiveDirectorySiteLinkBridge), bridgeName);
throw exception;
}
}
catch (COMException cOMException3)
{
COMException cOMException2 = cOMException3;
if (cOMException2.ErrorCode != -2147016656)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException2);
}
else
{
DirectoryEntry directoryEntry2 = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
if (!Utils.CheckCapability(directoryEntry2, Capability.ActiveDirectoryApplicationMode) || transport != ActiveDirectoryTransportType.Smtp)
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("DSNotFound"), typeof(ActiveDirectorySiteLinkBridge), bridgeName);
}
else
{
throw new NotSupportedException(Res.GetString("NotSupportTransportSMTP"));
}
}
}
}
finally
{
directoryEntry.Dispose();
}
return(activeDirectorySiteLinkBridge);
}
public static ConfigurationSet GetConfigurationSet(DirectoryContext context)
{
// check that the argument is not null
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// target should ConfigurationSet or DirectoryServer
if ((context.ContextType != DirectoryContextType.ConfigurationSet) &&
(context.ContextType != DirectoryContextType.DirectoryServer))
{
throw new ArgumentException(SR.TargetShouldBeServerORConfigSet, nameof(context));
}
// target should be an adam config set or server
if (((!context.isServer()) && (!context.isADAMConfigSet())))
{
// the target should be a server or an ADAM Config Set
if (context.ContextType == DirectoryContextType.ConfigurationSet)
{
throw new ActiveDirectoryObjectNotFoundException(SR.ConfigSetNotFound, typeof(ConfigurationSet), context.Name);
}
else
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.AINotFound, context.Name), typeof(ConfigurationSet), null);
}
}
// work with copy of the context
context = new DirectoryContext(context);
//
// bind to rootdse of an adam instance (if target is already a server, verify that it is an adam instance)
//
DirectoryEntryManager directoryEntryMgr = new DirectoryEntryManager(context);
DirectoryEntry rootDSE = null;
string configSetName = null;
try
{
rootDSE = directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if ((context.isServer()) && (!Utils.CheckCapability(rootDSE, Capability.ActiveDirectoryApplicationMode)))
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.AINotFound, context.Name), typeof(ConfigurationSet), null);
}
configSetName = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.ConfigurationNamingContext);
}
catch (COMException e)
{
int errorCode = e.ErrorCode;
if (errorCode == unchecked ((int)0x8007203a))
{
if (context.ContextType == DirectoryContextType.ConfigurationSet)
{
throw new ActiveDirectoryObjectNotFoundException(SR.ConfigSetNotFound, typeof(ConfigurationSet), context.Name);
}
else
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.AINotFound, context.Name), typeof(ConfigurationSet), null);
}
}
else
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
}
catch (ActiveDirectoryObjectNotFoundException)
{
if (context.ContextType == DirectoryContextType.ConfigurationSet)
{
// this is the case when we could not find an ADAM instance in that config set
throw new ActiveDirectoryObjectNotFoundException(SR.ConfigSetNotFound, typeof(ConfigurationSet), context.Name);
}
else
{
throw;
}
}
// return config set object
return(new ConfigurationSet(context, configSetName, directoryEntryMgr));
}
public ActiveDirectorySiteLinkBridge(DirectoryContext context, string bridgeName, ActiveDirectoryTransportType transport)
{
DirectoryEntry directoryEntry;
string str;
this.links = new ActiveDirectorySiteLinkCollection();
ActiveDirectorySiteLinkBridge.ValidateArgument(context, bridgeName, transport);
context = new DirectoryContext(context);
this.context = context;
this.name = bridgeName;
this.transport = transport;
try
{
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
string propertyValue = (string)PropertyManager.GetPropertyValue(context, directoryEntry, PropertyManager.ConfigurationNamingContext);
if (transport != ActiveDirectoryTransportType.Rpc)
{
str = string.Concat("CN=SMTP,CN=Inter-Site Transports,CN=Sites,", propertyValue);
}
else
{
str = string.Concat("CN=IP,CN=Inter-Site Transports,CN=Sites,", propertyValue);
}
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(context, str);
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException);
}
catch (ActiveDirectoryObjectNotFoundException activeDirectoryObjectNotFoundException)
{
object[] name = new object[1];
name[0] = context.Name;
throw new ActiveDirectoryOperationException(Res.GetString("ADAMInstanceNotFoundInConfigSet", name));
}
try
{
try
{
string escapedPath = string.Concat("cn=", this.name);
escapedPath = Utils.GetEscapedPath(escapedPath);
this.cachedEntry = directoryEntry.Children.Add(escapedPath, "siteLinkBridge");
}
catch (COMException cOMException3)
{
COMException cOMException2 = cOMException3;
if (cOMException2.ErrorCode == -2147016656)
{
DirectoryEntry directoryEntry1 = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
if (Utils.CheckCapability(directoryEntry1, Capability.ActiveDirectoryApplicationMode) && transport == ActiveDirectoryTransportType.Smtp)
{
throw new NotSupportedException(Res.GetString("NotSupportTransportSMTP"));
}
}
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException2);
}
}
finally
{
directoryEntry.Dispose();
}
}
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 string ExpandWellKnownDN(DirectoryContext context, WellKnownDN dn)
{
string?distinguishedName = null;
switch (dn)
{
case WellKnownDN.RootDSE:
{
distinguishedName = "RootDSE";
break;
}
case WellKnownDN.RootDomainNamingContext:
{
DirectoryEntry rootDSE = GetDirectoryEntry(context, "RootDSE");
try
{
distinguishedName = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.RootDomainNamingContext) !;
}
finally
{
rootDSE.Dispose();
}
break;
}
case WellKnownDN.DefaultNamingContext:
{
DirectoryEntry rootDSE = GetDirectoryEntry(context, "RootDSE");
try
{
distinguishedName = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.DefaultNamingContext) !;
}
finally
{
rootDSE.Dispose();
}
break;
}
case WellKnownDN.SchemaNamingContext:
{
DirectoryEntry rootDSE = GetDirectoryEntry(context, "RootDSE");
try
{
distinguishedName = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.SchemaNamingContext) !;
}
finally
{
rootDSE.Dispose();
}
break;
}
case WellKnownDN.ConfigurationNamingContext:
{
DirectoryEntry rootDSE = GetDirectoryEntry(context, "RootDSE");
try
{
distinguishedName = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.ConfigurationNamingContext) !;
}
finally
{
rootDSE.Dispose();
}
break;
}
case WellKnownDN.PartitionsContainer:
{
distinguishedName = "CN=Partitions," + ExpandWellKnownDN(context, WellKnownDN.ConfigurationNamingContext);
break;
}
case WellKnownDN.SitesContainer:
{
distinguishedName = "CN=Sites," + ExpandWellKnownDN(context, WellKnownDN.ConfigurationNamingContext);
break;
}
case WellKnownDN.SystemContainer:
{
distinguishedName = "CN=System," + ExpandWellKnownDN(context, WellKnownDN.DefaultNamingContext);
break;
}
case WellKnownDN.RidManager:
{
distinguishedName = "CN=RID Manager$," + ExpandWellKnownDN(context, WellKnownDN.SystemContainer);
break;
}
case WellKnownDN.Infrastructure:
{
distinguishedName = "CN=Infrastructure," + ExpandWellKnownDN(context, WellKnownDN.DefaultNamingContext);
break;
}
default:
// should not happen
throw new InvalidEnumArgumentException(nameof(dn), (int)dn, typeof(WellKnownDN));
}
return(distinguishedName);
}
internal ReplicationConnectionCollection GetInboundConnectionsHelper()
{
if (_inbound == null)
{
// construct the replicationconnection collection
_inbound = new ReplicationConnectionCollection();
DirectoryContext newContext = Utils.GetNewDirectoryContext(Name, DirectoryContextType.DirectoryServer, context);
// this is the first time that user tries to retrieve this property, so get it from the directory
string serverName = (this is DomainController) ? ((DomainController)this).ServerObjectName : ((AdamInstance)this).ServerObjectName;
string srchDN = "CN=NTDS Settings," + serverName;
DirectoryEntry de = DirectoryEntryManager.GetDirectoryEntry(Utils.GetNewDirectoryContext(Name, DirectoryContextType.DirectoryServer, context), srchDN);
ADSearcher adSearcher = new ADSearcher(de,
"(&(objectClass=nTDSConnection)(objectCategory=nTDSConnection))",
new string[] { "cn" },
SearchScope.OneLevel);
SearchResultCollection?srchResults = null;
try
{
srchResults = adSearcher.FindAll();
foreach (SearchResult r in srchResults)
{
ReplicationConnection con = new ReplicationConnection(newContext, r.GetDirectoryEntry(), (string)PropertyManager.GetSearchResultPropertyValue(r, PropertyManager.Cn) !);
_inbound.Add(con);
}
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(newContext, e);
}
finally
{
if (srchResults != null)
{
srchResults.Dispose();
}
de.Dispose();
}
}
return(_inbound);
}
public static GlobalCatalog GetGlobalCatalog(DirectoryContext context)
{
string gcDnsName = null;
bool isGlobalCatalog = false;
DirectoryEntryManager directoryEntryMgr = null;
// check that the context argument is not null
if (context == null)
{
throw new ArgumentNullException(nameof(context));
}
// target should be GC
if (context.ContextType != DirectoryContextType.DirectoryServer)
{
throw new ArgumentException(SR.TargetShouldBeGC, nameof(context));
}
// target should be a server
if (!(context.isServer()))
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.GCNotFound, context.Name), typeof(GlobalCatalog), context.Name);
}
// work with copy of the context
context = new DirectoryContext(context);
try
{
// Get dns name of the dc
// by binding to root dse and getting the "dnsHostName" attribute
// (also check that the "isGlobalCatalogReady" attribute is true)
directoryEntryMgr = new DirectoryEntryManager(context);
DirectoryEntry rootDSE = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
if (!Utils.CheckCapability(rootDSE, Capability.ActiveDirectory))
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.GCNotFound, context.Name), typeof(GlobalCatalog), context.Name);
}
gcDnsName = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.DnsHostName);
isGlobalCatalog = (bool)bool.Parse((string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.IsGlobalCatalogReady));
if (!isGlobalCatalog)
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.GCNotFound, context.Name), typeof(GlobalCatalog), context.Name);
}
}
catch (COMException e)
{
int errorCode = e.ErrorCode;
if (errorCode == unchecked ((int)0x8007203a))
{
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.GCNotFound, context.Name), typeof(GlobalCatalog), context.Name);
}
else
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
}
return(new GlobalCatalog(context, gcDnsName, directoryEntryMgr));
}
public static ConfigurationSet GetConfigurationSet(DirectoryContext context)
{
if (context != null)
{
if (context.ContextType == DirectoryContextType.ConfigurationSet || context.ContextType == DirectoryContextType.DirectoryServer)
{
if (context.isServer() || context.isADAMConfigSet())
{
context = new DirectoryContext(context);
DirectoryEntryManager directoryEntryManager = new DirectoryEntryManager(context);
string propertyValue = null;
try
{
DirectoryEntry cachedDirectoryEntry = directoryEntryManager.GetCachedDirectoryEntry(WellKnownDN.RootDSE);
if (!context.isServer() || Utils.CheckCapability(cachedDirectoryEntry, Capability.ActiveDirectoryApplicationMode))
{
propertyValue = (string)PropertyManager.GetPropertyValue(context, cachedDirectoryEntry, PropertyManager.ConfigurationNamingContext);
}
else
{
object[] name = new object[1];
name[0] = context.Name;
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AINotFound", name), typeof(ConfigurationSet), null);
}
}
catch (COMException cOMException1)
{
COMException cOMException = cOMException1;
int errorCode = cOMException.ErrorCode;
if (errorCode != -2147016646)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, cOMException);
}
else
{
if (context.ContextType != DirectoryContextType.ConfigurationSet)
{
object[] objArray = new object[1];
objArray[0] = context.Name;
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AINotFound", objArray), typeof(ConfigurationSet), null);
}
else
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ConfigSetNotFound"), typeof(ConfigurationSet), context.Name);
}
}
}
catch (ActiveDirectoryObjectNotFoundException activeDirectoryObjectNotFoundException)
{
if (context.ContextType != DirectoryContextType.ConfigurationSet)
{
throw;
}
else
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ConfigSetNotFound"), typeof(ConfigurationSet), context.Name);
}
}
return(new ConfigurationSet(context, propertyValue, directoryEntryManager));
}
else
{
if (context.ContextType != DirectoryContextType.ConfigurationSet)
{
object[] name1 = new object[1];
name1[0] = context.Name;
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("AINotFound", name1), typeof(ConfigurationSet), null);
}
else
{
throw new ActiveDirectoryObjectNotFoundException(Res.GetString("ConfigSetNotFound"), typeof(ConfigurationSet), context.Name);
}
}
}
else
{
throw new ArgumentException(Res.GetString("TargetShouldBeServerORConfigSet"), "context");
}
}
else
{
throw new ArgumentNullException("context");
}
}
public static ActiveDirectorySiteLink FindByName(DirectoryContext context, string siteLinkName, ActiveDirectoryTransportType transport)
{
ValidateArgument(context, siteLinkName, transport);
// work with copy of the context
context = new DirectoryContext(context);
// bind to the rootdse to get the configurationnamingcontext
DirectoryEntry de;
try
{
de = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
string config = (string)PropertyManager.GetPropertyValue(context, de, PropertyManager.ConfigurationNamingContext) !;
string containerDN = "CN=Inter-Site Transports,CN=Sites," + config;
if (transport == ActiveDirectoryTransportType.Rpc)
{
containerDN = "CN=IP," + containerDN;
}
else
{
containerDN = "CN=SMTP," + containerDN;
}
de = DirectoryEntryManager.GetDirectoryEntry(context, containerDN);
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
catch (ActiveDirectoryObjectNotFoundException)
{
// this is the case where the context is a config set and we could not find an ADAM instance in that config set
throw new ActiveDirectoryOperationException(SR.Format(SR.ADAMInstanceNotFoundInConfigSet, context.Name));
}
try
{
ADSearcher adSearcher = new ADSearcher(de,
"(&(objectClass=siteLink)(objectCategory=SiteLink)(name=" + Utils.GetEscapedFilterValue(siteLinkName) + "))",
new string[] { "distinguishedName" },
SearchScope.OneLevel,
false, /* don't need paged search */
false /* don't need to cache result */
);
SearchResult?srchResult = adSearcher.FindOne();
if (srchResult == null)
{
// no such sitelink object
Exception e = new ActiveDirectoryObjectNotFoundException(SR.DSNotFound, typeof(ActiveDirectorySiteLink), siteLinkName);
throw e;
}
else
{
DirectoryEntry connectionEntry = srchResult.GetDirectoryEntry();
// it is an existing site object
ActiveDirectorySiteLink link = new ActiveDirectorySiteLink(context, siteLinkName, transport, true, connectionEntry);
return(link);
}
}
catch (COMException e)
{
if (e.ErrorCode == unchecked ((int)0x80072030))
{
// if it is ADAM and transport type is SMTP, throw NotSupportedException.
DirectoryEntry tmpDE = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
if (Utils.CheckCapability(tmpDE, Capability.ActiveDirectoryApplicationMode) && transport == ActiveDirectoryTransportType.Smtp)
{
throw new NotSupportedException(SR.NotSupportTransportSMTP);
}
else
{
// object is not found since we cannot even find the container in which to search
throw new ActiveDirectoryObjectNotFoundException(SR.DSNotFound, typeof(ActiveDirectorySiteLink), siteLinkName);
}
}
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
finally
{
de.Dispose();
}
}
public static ActiveDirectoryInterSiteTransport FindByTransportType(DirectoryContext context, ActiveDirectoryTransportType transport)
{
if (context == null)
{
throw new ArgumentNullException("context");
}
// if target is not specified, then we determin the target from the logon credential, so if it is a local user context, it should fail
if ((context.Name == null) && (!context.isRootDomain()))
{
throw new ArgumentException(SR.ContextNotAssociatedWithDomain, "context");
}
// more validation for the context, if the target is not null, then it should be either forest name or server name
if (context.Name != null)
{
if (!(context.isRootDomain() || context.isServer() || context.isADAMConfigSet()))
{
throw new ArgumentException(SR.NotADOrADAM, "context");
}
}
if (transport < ActiveDirectoryTransportType.Rpc || transport > ActiveDirectoryTransportType.Smtp)
{
throw new InvalidEnumArgumentException("value", (int)transport, typeof(ActiveDirectoryTransportType));
}
// work with copy of the context
context = new DirectoryContext(context);
// bind to the rootdse to get the configurationnamingcontext
DirectoryEntry de;
try
{
de = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
string config = (string)PropertyManager.GetPropertyValue(context, de, PropertyManager.ConfigurationNamingContext);
string containerDN = "CN=Inter-Site Transports,CN=Sites," + config;
if (transport == ActiveDirectoryTransportType.Rpc)
{
containerDN = "CN=IP," + containerDN;
}
else
{
containerDN = "CN=SMTP," + containerDN;
}
de = DirectoryEntryManager.GetDirectoryEntry(context, containerDN);
}
catch (COMException e)
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
catch (ActiveDirectoryObjectNotFoundException)
{
// this is the case where the context is a config set and we could not find an ADAM instance in that config set
throw new ActiveDirectoryOperationException(SR.Format(SR.ADAMInstanceNotFoundInConfigSet, context.Name));
}
try
{
de.RefreshCache(new string[] { "options" });
}
catch (COMException e)
{
if (e.ErrorCode == unchecked ((int)0x80072030))
{
// if it is ADAM and transport type is SMTP, throw NotSupportedException.
DirectoryEntry tmpDE = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
if (Utils.CheckCapability(tmpDE, Capability.ActiveDirectoryApplicationMode) && transport == ActiveDirectoryTransportType.Smtp)
{
throw new NotSupportedException(SR.NotSupportTransportSMTP);
}
throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.TransportNotFound, transport.ToString()), typeof(ActiveDirectoryInterSiteTransport), transport.ToString());
}
else
{
throw ExceptionHelper.GetExceptionFromCOMException(context, e);
}
}
return(new ActiveDirectoryInterSiteTransport(context, transport, de));
}
private void ValidateTargetAndSourceServer(DirectoryContext context, DirectoryServer sourceServer)
{
bool flag = false;
DirectoryEntry rootDSE = null;
DirectoryEntry directoryEntry = null;
rootDSE = DirectoryEntryManager.GetDirectoryEntry(context, WellKnownDN.RootDSE);
try
{
if (Utils.CheckCapability(rootDSE, Capability.ActiveDirectory))
{
flag = true;
}
else if (!Utils.CheckCapability(rootDSE, Capability.ActiveDirectoryApplicationMode))
{
throw new ArgumentException(Res.GetString("DirectoryContextNeedHost"), "context");
}
if (flag && !(sourceServer is DomainController))
{
throw new ArgumentException(Res.GetString("ConnectionSourcServerShouldBeDC"), "sourceServer");
}
if (!flag && (sourceServer is DomainController))
{
throw new ArgumentException(Res.GetString("ConnectionSourcServerShouldBeADAM"), "sourceServer");
}
directoryEntry = DirectoryEntryManager.GetDirectoryEntry(sourceServer.Context, WellKnownDN.RootDSE);
if (flag)
{
string str = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.RootDomainNamingContext);
string str2 = (string)PropertyManager.GetPropertyValue(sourceServer.Context, directoryEntry, PropertyManager.RootDomainNamingContext);
if (Utils.Compare(str, str2) != 0)
{
throw new ArgumentException(Res.GetString("ConnectionSourcServerSameForest"), "sourceServer");
}
}
else
{
string str3 = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.ConfigurationNamingContext);
string str4 = (string)PropertyManager.GetPropertyValue(sourceServer.Context, directoryEntry, PropertyManager.ConfigurationNamingContext);
if (Utils.Compare(str3, str4) != 0)
{
throw new ArgumentException(Res.GetString("ConnectionSourcServerSameConfigSet"), "sourceServer");
}
}
}
catch (COMException exception)
{
ExceptionHelper.GetExceptionFromCOMException(context, exception);
}
finally
{
if (rootDSE != null)
{
rootDSE.Close();
}
if (directoryEntry != null)
{
directoryEntry.Close();
}
}
}