public void SetSecurityLevel(ReplicationSecurityLevel securityLevel) { CheckIfDisposed(); if (securityLevel < ReplicationSecurityLevel.NegotiatePassThrough || securityLevel > ReplicationSecurityLevel.MutualAuthentication) { throw new InvalidEnumArgumentException(nameof(securityLevel), (int)securityLevel, typeof(ReplicationSecurityLevel)); } try { DirectoryEntry configEntry = _directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.ConfigurationNamingContext); configEntry.Properties[PropertyManager.MsDSReplAuthenticationMode].Value = (int)securityLevel; configEntry.CommitChanges(); } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(_context, e); } // invalidate the cached entry _cachedSecurityLevel = (ReplicationSecurityLevel)(-1); }
private ArrayList GetSites() { ArrayList sites = new ArrayList(); DirectoryEntry sitesEntry = _directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.SitesContainer); // search for all the "site" objects // (one-level search is good enough) // setup the directory searcher object string filter = "(" + PropertyManager.ObjectCategory + "=site)"; string[] propertiesToLoad = new string[1]; propertiesToLoad[0] = PropertyManager.Cn; ADSearcher searcher = new ADSearcher(sitesEntry, filter, propertiesToLoad, SearchScope.OneLevel); SearchResultCollection?resCol = null; try { resCol = searcher.FindAll(); foreach (SearchResult res in resCol) { // an existing site sites.Add(new ActiveDirectorySite(_context, (string)PropertyManager.GetSearchResultPropertyValue(res, PropertyManager.Cn) !, true)); } } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(_context, e); } finally { // call dispose on search result collection resCol?.Dispose(); } return(sites); }
public void Save() { if (this.disposed) { throw new ObjectDisposedException(base.GetType().Name); } try { if (this.existing) { if (this.site == null) { if (this.cachedEntry.Properties.Contains("siteObject")) { this.cachedEntry.Properties["siteObject"].Clear(); } } else { this.cachedEntry.Properties["siteObject"].Value = this.site.cachedEntry.Properties["distinguishedName"][0]; } this.cachedEntry.CommitChanges(); } else { if (this.Site != null) { this.cachedEntry.Properties["siteObject"].Add(this.site.cachedEntry.Properties["distinguishedName"][0]); } this.cachedEntry.CommitChanges(); this.existing = true; } } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception); } }
private void InitializeCrossRef(string distinguishedName) { if (this.crossRefEntry == null) { DirectoryEntry directoryEntry = null; try { directoryEntry = DirectoryEntryManager.GetDirectoryEntry(Utils.GetNewDirectoryContext(this.GetNamingRoleOwner(), DirectoryContextType.DirectoryServer, base.context), WellKnownDN.PartitionsContainer); string name = "CN={" + Guid.NewGuid() + "}"; this.crossRefEntry = directoryEntry.Children.Add(name, "crossRef"); string adamHostNameAndPortsFromNTDSA = null; if (this.appType == ApplicationPartitionType.ADAMApplicationPartition) { DirectoryEntry cachedDirectoryEntry = base.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE); string dn = (string)PropertyManager.GetPropertyValue(base.context, cachedDirectoryEntry, PropertyManager.DsServiceName); adamHostNameAndPortsFromNTDSA = Utils.GetAdamHostNameAndPortsFromNTDSA(base.context, dn); } else { adamHostNameAndPortsFromNTDSA = base.context.Name; } this.crossRefEntry.Properties[PropertyManager.DnsRoot].Value = adamHostNameAndPortsFromNTDSA; this.crossRefEntry.Properties[PropertyManager.Enabled].Value = false; this.crossRefEntry.Properties[PropertyManager.NCName].Value = distinguishedName; } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception); } finally { if (directoryEntry != null) { directoryEntry.Dispose(); } } } }
private System.DirectoryServices.ActiveDirectory.ForestMode GetForestMode() { System.DirectoryServices.ActiveDirectory.ForestMode mode; DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, WellKnownDN.RootDSE); try { if (!directoryEntry.Properties.Contains(PropertyManager.ForestFunctionality)) { return(System.DirectoryServices.ActiveDirectory.ForestMode.Windows2000Forest); } return((System.DirectoryServices.ActiveDirectory.ForestMode) int.Parse((string)directoryEntry.Properties[PropertyManager.ForestFunctionality].Value, NumberFormatInfo.InvariantInfo)); } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception); } finally { directoryEntry.Dispose(); } return(mode); }
public DomainController DisableGlobalCatalog() { base.CheckIfDisposed(); this.CheckIfDisabled(); DirectoryEntry cachedDirectoryEntry = base.directoryEntryMgr.GetCachedDirectoryEntry(base.NtdsaObjectName); int num = 0; try { if (cachedDirectoryEntry.Properties[PropertyManager.Options].Value != null) { num = (int)cachedDirectoryEntry.Properties[PropertyManager.Options].Value; } cachedDirectoryEntry.Properties[PropertyManager.Options].Value = num & -2; cachedDirectoryEntry.CommitChanges(); } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception); } this.disabled = true; return(new DomainController(base.context, base.Name)); }
public static object GetSearchResultPropertyValue(SearchResult res, string propertyName) { Debug.Assert(res != null, "PropertyManager::GetSearchResultPropertyValue - res is null"); Debug.Assert(propertyName != null, "PropertyManager::GetSearchResultPropertyValue - propertyName is null"); ResultPropertyValueCollection propertyValues = null; try { propertyValues = res.Properties[propertyName]; if ((propertyValues == null) || (propertyValues.Count < 1)) { throw new ActiveDirectoryOperationException(SR.Format(SR.PropertyNotFound, propertyName)); } } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(e); } return(propertyValues[0]); }
public void Delete() { base.CheckIfDisposed(); if (!this.committed) { throw new InvalidOperationException(Res.GetString("CannotPerformOperationOnUncommittedObject")); } DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(base.context, base.directoryEntryMgr.ExpandWellKnownDN(WellKnownDN.PartitionsContainer)); try { this.GetCrossRefEntry(); directoryEntry.Children.Remove(this.crossRefEntry); } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(base.context, exception); } finally { directoryEntry.Dispose(); } }
protected override void OnRemoveComplete(int index, object value) { ActiveDirectorySubnet subnet = (ActiveDirectorySubnet)value; string key = (string)PropertyManager.GetPropertyValue(subnet.context, subnet.cachedEntry, PropertyManager.DistinguishedName); try { if (this.changeList.Contains(key)) { ((DirectoryEntry)this.changeList[key]).Properties["siteObject"].Clear(); } else { DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, this.MakePath(key)); directoryEntry.Properties["siteObject"].Clear(); this.changeList.Add(key, directoryEntry); } } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception); } }
public void Delete() { if (_disposed) { throw new ObjectDisposedException(GetType().Name); } if (!existing) { throw new InvalidOperationException(Res.GetString(Res.CannotDelete)); } else { try { cachedEntry.Parent.Children.Remove(cachedEntry); } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(context, e); } } }
protected override void OnRemoveComplete(int index, object value) { ActiveDirectorySubnet subnet = (ActiveDirectorySubnet)value; string dn = (string)PropertyManager.GetPropertyValue(subnet.context, subnet.cachedEntry, PropertyManager.DistinguishedName); try { if (changeList.Contains(dn)) { ((DirectoryEntry)changeList[dn]).Properties["siteObject"].Clear(); } else { DirectoryEntry de = DirectoryEntryManager.GetDirectoryEntry(_context, MakePath(dn)); de.Properties["siteObject"].Clear(); changeList.Add(dn, de); } } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(_context, e); } }
protected override void OnRemoveComplete(int index, object value) { if (this.isBound) { if (this.classEntry == null) { this.classEntry = this.schemaClass.GetSchemaClassDirectoryEntry(); } string name = ((ActiveDirectorySchemaProperty)value).Name; try { if (!this.classEntry.Properties[this.propertyName].Contains(name)) { throw new ActiveDirectoryOperationException(Res.GetString("ValueCannotBeModified")); } this.classEntry.Properties[this.propertyName].Remove(name); } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception); } } }
public void Save() { if (this.disposed) { throw new ObjectDisposedException(base.GetType().Name); } try { this.cachedEntry.CommitChanges(); } catch (COMException exception) { throw ExceptionHelper.GetExceptionFromCOMException(this.context, exception); } if (this.existing) { this.siteRetrieved = false; } else { this.existing = true; } }
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 void SeizeRoleOwnership(AdamRole role) { string str = null; base.CheckIfDisposed(); AdamRole adamRole = role; if (adamRole == AdamRole.SchemaRole) { str = this.directoryEntryMgr.ExpandWellKnownDN(WellKnownDN.SchemaNamingContext); } else if (adamRole == AdamRole.NamingRole) { str = this.directoryEntryMgr.ExpandWellKnownDN(WellKnownDN.PartitionsContainer); } else { throw new InvalidEnumArgumentException("role", (int)role, typeof(AdamRole)); } DirectoryEntry directoryEntry = null; using (directoryEntry) { try { directoryEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, str); directoryEntry.Properties[PropertyManager.FsmoRoleOwner].Value = this.NtdsaObjectName; directoryEntry.CommitChanges(); } catch (COMException cOMException1) { COMException cOMException = cOMException1; throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException); } } this.cachedRoles = null; }
public void TransferRoleOwnership(AdamRole role) { base.CheckIfDisposed(); if (role < AdamRole.SchemaRole || role > AdamRole.NamingRole) { throw new InvalidEnumArgumentException("role", (int)role, typeof(AdamRole)); } else { try { DirectoryEntry cachedDirectoryEntry = this.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE); cachedDirectoryEntry.Properties[this.becomeRoleOwnerAttrs[(int)role]].Value = 1; cachedDirectoryEntry.CommitChanges(); } catch (COMException cOMException1) { COMException cOMException = cOMException1; throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException); } this.cachedRoles = null; return; } }
public void Save() { if (!this.disposed) { try { this.cachedDirectoryEntry.CommitChanges(); } catch (COMException cOMException1) { COMException cOMException = cOMException1; throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException); } if (!this.existingConnection) { this.existingConnection = true; } return; } else { throw new ObjectDisposedException(this.GetType().Name); } }
public void SetSecurityLevel(ReplicationSecurityLevel securityLevel) { this.CheckIfDisposed(); if (securityLevel < ReplicationSecurityLevel.NegotiatePassThrough || securityLevel > ReplicationSecurityLevel.MutualAuthentication) { throw new InvalidEnumArgumentException("securityLevel", (int)securityLevel, typeof(ReplicationSecurityLevel)); } else { try { DirectoryEntry cachedDirectoryEntry = this.directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.ConfigurationNamingContext); cachedDirectoryEntry.Properties[PropertyManager.MsDSReplAuthenticationMode].Value = (int)securityLevel; cachedDirectoryEntry.CommitChanges(); } catch (COMException cOMException1) { COMException cOMException = cOMException1; throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException); } this.cachedSecurityLevel = ReplicationSecurityLevel.MutualAuthentication | ReplicationSecurityLevel.Negotiate; return; } }
public void TransferRoleOwnership(AdamRole role) { CheckIfDisposed(); if (role < AdamRole.SchemaRole || role > AdamRole.NamingRole) { throw new InvalidEnumArgumentException(nameof(role), (int)role, typeof(AdamRole)); } // set the appropriate attribute on the root dse try { DirectoryEntry rootDSE = directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE); rootDSE.Properties[_becomeRoleOwnerAttrs[(int)role]].Value = 1; rootDSE.CommitChanges(); } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(context, e); } // invalidate the role collection so that it gets loaded again next time _cachedRoles = null; }
protected override void OnRemoveComplete(int index, object value) { ActiveDirectorySubnet activeDirectorySubnet = (ActiveDirectorySubnet)value; string propertyValue = (string)PropertyManager.GetPropertyValue(activeDirectorySubnet.context, activeDirectorySubnet.cachedEntry, PropertyManager.DistinguishedName); try { if (!this.changeList.Contains(propertyValue)) { DirectoryEntry directoryEntry = DirectoryEntryManager.GetDirectoryEntry(this.context, this.MakePath(propertyValue)); directoryEntry.Properties["siteObject"].Clear(); this.changeList.Add(propertyValue, directoryEntry); } else { ((DirectoryEntry)this.changeList[propertyValue]).Properties["siteObject"].Clear(); } } catch (COMException cOMException1) { COMException cOMException = cOMException1; throw ExceptionHelper.GetExceptionFromCOMException(this.context, cOMException); } }
public ReadOnlyActiveDirectorySchemaPropertyCollection FindAllProperties() { CheckIfDisposed(); CheckIfDisabled(); // create an ActiveDirectorySchema object if (_schema == null) { string?schemaNC = null; try { schemaNC = directoryEntryMgr.ExpandWellKnownDN(WellKnownDN.SchemaNamingContext); } catch (COMException e) { throw ExceptionHelper.GetExceptionFromCOMException(context, e); } _ = Utils.GetNewDirectoryContext(Name, DirectoryContextType.DirectoryServer, context); _schema = new ActiveDirectorySchema(context, schemaNC); } // return the global catalog replicated properties return(_schema.FindAllProperties(PropertyTypes.InGlobalCatalog)); }
public static ActiveDirectorySchema GetSchema(DirectoryContext context) { if (context == null) { throw new ArgumentNullException(nameof(context)); } // contexttype should be Forest, DirectoryServer or ConfigurationSet if ((context.ContextType != DirectoryContextType.Forest) && (context.ContextType != DirectoryContextType.ConfigurationSet) && (context.ContextType != DirectoryContextType.DirectoryServer)) { throw new ArgumentException(SR.NotADOrADAM, nameof(context)); } if ((context.Name == null) && (!context.isRootDomain())) { throw new ActiveDirectoryObjectNotFoundException(SR.ContextNotAssociatedWithDomain, typeof(ActiveDirectorySchema), null); } if (context.Name != null) { // the target should be a valid forest name or a server if (!((context.isRootDomain()) || (context.isADAMConfigSet()) || (context.isServer()))) { if (context.ContextType == DirectoryContextType.Forest) { throw new ActiveDirectoryObjectNotFoundException(SR.ForestNotFound, typeof(ActiveDirectorySchema), context.Name); } else if (context.ContextType == DirectoryContextType.ConfigurationSet) { throw new ActiveDirectoryObjectNotFoundException(SR.ConfigSetNotFound, typeof(ActiveDirectorySchema), context.Name); } else { throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.ServerNotFound, context.Name), typeof(ActiveDirectorySchema), null); } } } // work with copy of the context context = new DirectoryContext(context); DirectoryEntryManager directoryEntryMgr = new DirectoryEntryManager(context); string schemaNC = null; try { DirectoryEntry rootDSE = directoryEntryMgr.GetCachedDirectoryEntry(WellKnownDN.RootDSE); if ((context.isServer()) && (!Utils.CheckCapability(rootDSE, Capability.ActiveDirectoryOrADAM))) { throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.ServerNotFound, context.Name), typeof(ActiveDirectorySchema), null); } schemaNC = (string)PropertyManager.GetPropertyValue(context, rootDSE, PropertyManager.SchemaNamingContext); } catch (COMException e) { int errorCode = e.ErrorCode; if (errorCode == unchecked ((int)0x8007203a)) { if (context.ContextType == DirectoryContextType.Forest) { throw new ActiveDirectoryObjectNotFoundException(SR.ForestNotFound, typeof(ActiveDirectorySchema), context.Name); } else if (context.ContextType == DirectoryContextType.ConfigurationSet) { throw new ActiveDirectoryObjectNotFoundException(SR.ConfigSetNotFound, typeof(ActiveDirectorySchema), context.Name); } else { throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.ServerNotFound, context.Name), typeof(ActiveDirectorySchema), null); } } else { throw ExceptionHelper.GetExceptionFromCOMException(context, e); } } catch (ActiveDirectoryObjectNotFoundException) { if (context.ContextType == DirectoryContextType.ConfigurationSet) { // 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 ActiveDirectoryObjectNotFoundException(SR.ConfigSetNotFound, typeof(ActiveDirectorySchema), context.Name); } else { throw; } } return(new ActiveDirectorySchema(context, schemaNC, directoryEntryMgr)); }
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 = null; 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(String.Format(CultureInfo.CurrentCulture, 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["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(); } }
public static ActiveDirectorySubnet FindByName(DirectoryContext context, string subnetName) { ValidateArgument(context, subnetName); // 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 subnetdn = "CN=Subnets,CN=Sites," + config; de = DirectoryEntryManager.GetDirectoryEntry(context, subnetdn); } 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(Res.GetString(Res.ADAMInstanceNotFoundInConfigSet, context.Name)); } try { ADSearcher adSearcher = new ADSearcher(de, "(&(objectClass=subnet)(objectCategory=subnet)(name=" + Utils.GetEscapedFilterValue(subnetName) + "))", 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 subnet object Exception e = new ActiveDirectoryObjectNotFoundException(Res.GetString(Res.DSNotFound), typeof(ActiveDirectorySubnet), subnetName); throw e; } else { string siteName = null; DirectoryEntry connectionEntry = srchResult.GetDirectoryEntry(); // try to get the site that this subnet lives in if (connectionEntry.Properties.Contains("siteObject")) { NativeComInterfaces.IAdsPathname pathCracker = (NativeComInterfaces.IAdsPathname) new NativeComInterfaces.Pathname(); // need to turn off the escaping for name pathCracker.EscapedMode = NativeComInterfaces.ADS_ESCAPEDMODE_OFF_EX; string tmp = (string)connectionEntry.Properties["siteObject"][0]; // escaping manipulation pathCracker.Set(tmp, NativeComInterfaces.ADS_SETTYPE_DN); string rdn = pathCracker.Retrieve(NativeComInterfaces.ADS_FORMAT_LEAF); Debug.Assert(rdn != null && Utils.Compare(rdn, 0, 3, "CN=", 0, 3) == 0); siteName = rdn.Substring(3); } // it is an existing subnet object ActiveDirectorySubnet subnet = null; if (siteName == null) { subnet = new ActiveDirectorySubnet(context, subnetName, null, true); } else { subnet = new ActiveDirectorySubnet(context, subnetName, siteName, true); } subnet.cachedEntry = connectionEntry; return(subnet); } } catch (COMException e) { if (e.ErrorCode == unchecked ((int)0x80072030)) { // object is not found since we cannot even find the container in which to search throw new ActiveDirectoryObjectNotFoundException(Res.GetString(Res.DSNotFound), typeof(ActiveDirectorySubnet), subnetName); } else { throw ExceptionHelper.GetExceptionFromCOMException(context, e); } } finally { if (de != null) { de.Dispose(); } } }
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)); }
internal static new GlobalCatalog FindOneWithCredentialValidation(DirectoryContext context, string?siteName, LocatorOptions flag) { GlobalCatalog gc; bool retry = false; bool credsValidated = false; // work with copy of the context context = new DirectoryContext(context); // authenticate against this GC to validate the credentials gc = FindOneInternal(context, context.Name, siteName, flag); try { ValidateCredential(gc, context); credsValidated = true; } catch (COMException e) { if (e.ErrorCode == unchecked ((int)0x8007203a)) { // server is down , so try again with force rediscovery if the flags did not already contain force rediscovery if ((flag & LocatorOptions.ForceRediscovery) == 0) { retry = true; } else { throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.GCNotFoundInForest, context.Name), typeof(GlobalCatalog), null); } } else { throw ExceptionHelper.GetExceptionFromCOMException(context, e); } } finally { if (!credsValidated) { gc.Dispose(); } } if (retry) { credsValidated = false; gc = FindOneInternal(context, context.Name, siteName, flag | LocatorOptions.ForceRediscovery); try { ValidateCredential(gc, context); credsValidated = true; } catch (COMException e) { if (e.ErrorCode == unchecked ((int)0x8007203a)) { // server is down throw new ActiveDirectoryObjectNotFoundException(SR.Format(SR.GCNotFoundInForest, context.Name), typeof(GlobalCatalog), null); } else { throw ExceptionHelper.GetExceptionFromCOMException(context, e); } } finally { if (!credsValidated) { gc.Dispose(); } } } return(gc); }
public void MoveToAnotherSite(string siteName) { CheckIfDisposed(); // validate siteName if (siteName == null) { throw new ArgumentNullException("siteName"); } if (siteName.Length == 0) { throw new ArgumentException(SR.EmptyStringParameter, "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 dn = (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; } } }
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)); }
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); }
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)); }