protected override void WriteResult(IConfigurable dataObject) { TaskLogger.LogEnter(new object[] { dataObject.Identity, dataObject }); AcceptedDomain acceptedDomain = null; SyncOrganization syncOrganization = (SyncOrganization)dataObject; SmtpDomain federatedNamespace = null; SmtpDomainWithSubdomains provisioningDomain = null; if (syncOrganization.FederatedTenant) { acceptedDomain = this.ResolveDefaultAcceptedDomain(); federatedNamespace = acceptedDomain.DomainName.SmtpDomain; } if (syncOrganization.ProvisioningDomain == null) { if (syncOrganization.FederatedTenant) { provisioningDomain = acceptedDomain.DomainName; } else { acceptedDomain = this.ResolveDefaultAcceptedDomain(); provisioningDomain = acceptedDomain.DomainName; } } base.WriteResult(new SyncConfig((SyncOrganization)dataObject, federatedNamespace, provisioningDomain)); TaskLogger.LogExit(); }
protected override void InternalValidate() { TaskLogger.LogEnter(); base.InternalValidate(); this.CheckForDuplicateExistingDomain(); AcceptedDomain acceptedDomain = new AcceptedDomain(); acceptedDomain.Name = this.Name; acceptedDomain.DomainName = new SmtpDomainWithSubdomains(this.DomainName, false); acceptedDomain.DomainType = this.DomainType; acceptedDomain.SetId(base.Session, this.DomainName.ToString()); acceptedDomain.OrganizationId = base.CurrentOrganizationId; NewAcceptedDomain.ValidateDomainName(acceptedDomain, new Task.TaskErrorLoggingDelegate(this.WriteWrappedError)); if (!this.DomainOwnershipVerified && this.AuthenticationType == AuthenticationType.Federated) { bool flag = false; AcceptedDomainIdParameter acceptedDomainIdParameter = AcceptedDomainIdParameter.Parse("*"); IEnumerable <AcceptedDomain> objects = acceptedDomainIdParameter.GetObjects <AcceptedDomain>(this.TenantCU.Id, base.Session); foreach (AcceptedDomain acceptedDomain2 in objects) { SmtpDomainWithSubdomains smtpDomainWithSubdomains = new SmtpDomainWithSubdomains(acceptedDomain2.DomainName.Domain.ToString(), true); if (smtpDomainWithSubdomains.Match(this.DomainName.ToString()) == acceptedDomain2.DomainName.Domain.Length) { flag = true; break; } } if (!flag) { base.WriteError(new OrganizationTaskException(Strings.ErrorTenantAdminsCanOnlyAddSubdomains(this.DomainName.ToString())), ErrorCategory.InvalidOperation, null); } } TaskLogger.LogExit(); }
public IEnumerable <AcceptedDomain> GetAcceptedDomain() { IEnumerable <AcceptedDomain> result; try { object[] array = this.monadProvider.ExecuteCommand("Get-AcceptedDomain"); if (array != null && array.Length > 0) { AcceptedDomain[] array2 = new AcceptedDomain[array.Length]; for (int i = 0; i < array.Length; i++) { array2[i] = (AcceptedDomain)array[i]; } result = array2; } else { result = null; } } catch { result = null; } return(result); }
private bool IsValidExternalRecipient(ADRecipient mailboxOwner, string recipient, ADRecipient adRecipient) { string domain = new SmtpAddress(recipient).Domain; if (adRecipient == null) { if (SharingProviderHandlerExternal.IsOrganizationHasOrganizationRelationshipWithDomain(mailboxOwner.OrganizationId, domain)) { ExTraceGlobals.SharingTracer.TraceDebug <ADRecipient, string, string>((long)this.GetHashCode(), "{0}: Found OrganizationRelationship with domain {1}, so {2} this is valid external recipient.", mailboxOwner, domain, recipient); return(true); } } else if (SharingProviderHandlerExternal.IsOrganizationHasOrganizationRelationshipWithRecipient(mailboxOwner.OrganizationId, adRecipient)) { ExTraceGlobals.SharingTracer.TraceDebug <ADRecipient, string>((long)this.GetHashCode(), "{0}: Found OrganizationRelationship that matches one of proxy addresses of {1}, this is valid external recipient.", mailboxOwner, recipient); return(true); } ExTraceGlobals.SharingTracer.TraceDebug <ADRecipient, string>((long)this.GetHashCode(), "{0}: Found NO OrganizationRelationship with {1}.", mailboxOwner, recipient); IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.FullyConsistent, mailboxOwner.OrganizationId.ToADSessionSettings(), 485, "IsValidExternalRecipient", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\Sharing\\SharingProviderHandlerExternal.cs"); AcceptedDomain acceptedDomainByDomainName = tenantOrTopologyConfigurationSession.GetAcceptedDomainByDomainName(domain); if (acceptedDomainByDomainName != null) { ExTraceGlobals.SharingTracer.TraceDebug <ADRecipient, string>((long)this.GetHashCode(), "{0}: found AcceptedDomain for {1}'s domain, this is NOT valid external recipient.", mailboxOwner, recipient); return(false); } ExTraceGlobals.SharingTracer.TraceDebug <ADRecipient, string>((long)this.GetHashCode(), "{0}: found no AcceptedDomain for {1}'1 domain, this is a valid external recipient.", mailboxOwner, recipient); return(true); }
private List <AcceptedDomain> GetAllFederatedDomains(FederatedOrganizationId fedOrgId) { QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, ADObjectSchema.Guid, fedOrgId.Guid); ADRawEntry[] array = this.ConfigurationSession.Find(base.CurrentOrgContainerId, QueryScope.SubTree, filter, null, 1, new ADPropertyDefinition[] { FederatedOrganizationIdSchema.AcceptedDomainsBackLink }); if (array == null || array.Length == 0) { base.WriteError(new InvalidOperationException(Strings.CannotLocateFedOrgId), ErrorCategory.InvalidOperation, null); } MultiValuedProperty <ADObjectId> multiValuedProperty = array[0][FederatedOrganizationIdSchema.AcceptedDomainsBackLink] as MultiValuedProperty <ADObjectId>; List <AcceptedDomain> list = new List <AcceptedDomain>(multiValuedProperty.Count); foreach (ADObjectId entryId in multiValuedProperty) { AcceptedDomain acceptedDomain = this.ConfigurationSession.Read <AcceptedDomain>(entryId); if (acceptedDomain != null) { list.Add(acceptedDomain); } } return(list); }
protected AcceptedDomain GetAcceptedDomain(SmtpDomain domain, bool suppressChecks) { QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, AcceptedDomainSchema.DomainName, domain.Domain); AcceptedDomain[] array = base.DataSession.Find <AcceptedDomain>(filter, base.CurrentOrgContainerId, true, null) as AcceptedDomain[]; if (array == null || array.Length == 0) { filter = new ComparisonFilter(ComparisonOperator.Equal, AcceptedDomainSchema.DomainName, "*." + domain.Domain); array = (base.DataSession.Find <AcceptedDomain>(filter, base.CurrentOrgContainerId, true, null) as AcceptedDomain[]); if (array == null || array.Length == 0) { base.WriteError(new DomainNameNotAcceptedDomainException(domain.Domain), ErrorCategory.InvalidOperation, null); } else { base.WriteError(new AcceptedDomainsWithSubdomainsException(domain.Domain), ErrorCategory.InvalidOperation, null); } } AcceptedDomain acceptedDomain = array[0]; if (suppressChecks) { return(acceptedDomain); } if (acceptedDomain.DomainName.IncludeSubDomains) { base.WriteError(new AcceptedDomainsWithSubdomainsException(domain.Domain), ErrorCategory.InvalidOperation, null); } if (acceptedDomain.DomainType != AcceptedDomainType.Authoritative && AcceptedDomainType.InternalRelay != acceptedDomain.DomainType) { base.WriteError(new AcceptedDomainsInvalidTypeException(domain.Domain), ErrorCategory.InvalidOperation, null); } return(acceptedDomain); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); IEnumerable <AcceptedDomain> enumerable = base.DataSession.FindPaged <AcceptedDomain>(null, base.CurrentOrgContainerId, true, null, 0); using (IEnumerator <AcceptedDomain> enumerator = enumerable.GetEnumerator()) { while (enumerator.MoveNext()) { AcceptedDomain acceptedDomain = enumerator.Current; bool pendingFederatedAccountNamespace = acceptedDomain.PendingFederatedAccountNamespace; bool pendingFederatedDomain = acceptedDomain.PendingFederatedDomain; acceptedDomain.PendingFederatedAccountNamespace = false; acceptedDomain.PendingFederatedDomain = false; if (acceptedDomain.DomainName.SmtpDomain.Equals(this.PendingAccountNamespace)) { acceptedDomain.PendingFederatedAccountNamespace = true; } if (this.PendingDomains != null) { if (Array.Exists <SmtpDomain>(this.PendingDomains, (SmtpDomain pendingDomain) => pendingDomain.Equals(acceptedDomain.DomainName.SmtpDomain))) { acceptedDomain.PendingFederatedDomain = true; } } if (acceptedDomain.PendingFederatedAccountNamespace != pendingFederatedAccountNamespace || acceptedDomain.PendingFederatedDomain != pendingFederatedDomain) { base.DataSession.Save(acceptedDomain); } } } TaskLogger.LogExit(); }
// Token: 0x06000326 RID: 806 RVA: 0x00011034 File Offset: 0x0000F234 private static bool ValidateDomainName(AcceptedDomain domain, IConfigurationSession session, Exception duplicateAcceptedDomainException, Exception conflictingAcceptedDomainException, out Exception error) { error = null; string domain2 = domain.DomainName.Domain; QueryFilter filter = new AndFilter(new QueryFilter[] { new ComparisonFilter(ComparisonOperator.NotEqual, ADObjectSchema.Guid, domain.Guid), new OrFilter(new QueryFilter[] { new ComparisonFilter(ComparisonOperator.Equal, AcceptedDomainSchema.DomainName, domain2), new ComparisonFilter(ComparisonOperator.Equal, AcceptedDomainSchema.DomainName, "*." + domain2) }) }); AcceptedDomain[] array = session.Find <AcceptedDomain>(null, QueryScope.SubTree, filter, null, 1); if (array.Length != 0) { error = duplicateAcceptedDomainException; return(false); } List <QueryFilter> list = new List <QueryFilter>(AcceptedDomain.ConflictingDomainFilters(domain, false)); QueryFilter filter2 = new OrFilter(list.ToArray()); foreach (AcceptedDomain acceptedDomain in session.FindPaged <AcceptedDomain>(null, QueryScope.SubTree, filter2, null, 0)) { if (!ADObjectId.Equals(domain.Id.Parent, acceptedDomain.Id.Parent)) { error = conflictingAcceptedDomainException; return(false); } } return(true); }
public static void ExtractTenantDomainInfo(DataRow inputRow, DataTable dataTable, DataObjectStore store) { IEnumerable <object> enumerable = store.GetDataObject("AcceptedDomain") as IEnumerable <object>; List <string> list = new List <string>(); bool flag = false; if (enumerable != null) { foreach (object obj in enumerable) { AcceptedDomain acceptedDomain = (AcceptedDomain)obj; if (!flag && acceptedDomain.IsCoexistenceDomain) { flag = true; } if (!acceptedDomain.IsCoexistenceDomain && acceptedDomain.DomainName.SmtpDomain != null) { list.Add(acceptedDomain.DomainName.SmtpDomain.ToString()); } } } DataRow dataRow = dataTable.NewRow(); dataRow["HasCoexistenceDomain"] = flag; dataRow["DomainNames"] = string.Join(",", list.ToArray()); dataTable.Rows.Add(dataRow); }
// Token: 0x06000A74 RID: 2676 RVA: 0x00028DA0 File Offset: 0x00026FA0 internal static bool VerifyDeploymentId(string deploymentId, string domain) { if (!string.IsNullOrWhiteSpace(deploymentId)) { try { ADSessionSettings adsessionSettings = ExtensionDataHelper.CreateRootOrgOrSingleTenantFromAcceptedDomainAutoDetect(domain); if (adsessionSettings != null) { IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, adsessionSettings, 142, "VerifyDeploymentId", "f:\\15.00.1497\\sources\\dev\\data\\src\\ApplicationLogic\\extension\\ExtensionDataHelper.cs"); AcceptedDomain acceptedDomainByDomainName = tenantOrTopologyConfigurationSession.GetAcceptedDomainByDomainName(deploymentId); if (acceptedDomainByDomainName != null) { return(true); } } } catch (ADTransientException ex) { ExtensionDataHelper.Tracer.TraceError <string>(0L, "Failed to get accepted domain by deployment id. Exception: {0}", ex.Message); } return(false); } return(false); }
protected override void PrepareRecipientObject(ADMicrosoftExchangeRecipient dataObject) { this.DataObject = dataObject; dataObject.HiddenFromAddressListsEnabled = true; dataObject.EmailAddressPolicyEnabled = true; dataObject.Name = ADMicrosoftExchangeRecipient.DefaultName; dataObject.Alias = ADMicrosoftExchangeRecipient.DefaultName; dataObject.SetId(ADMicrosoftExchangeRecipient.GetDefaultId(this.ConfigurationSession)); dataObject.ObjectCategory = base.PartitionConfigSession.SchemaNamingContext.GetChildId("ms-Exch-Exchange-Server-Recipient"); if (string.IsNullOrEmpty(dataObject.LegacyExchangeDN)) { string parentLegacyDN = string.Format(CultureInfo.InvariantCulture, "/o={0}/ou={1}/cn=Recipients", new object[] { base.RootOrgGlobalConfigSession.GetOrgContainerId().Name, base.RootOrgGlobalConfigSession.GetAdministrativeGroupId().Name }); dataObject.LegacyExchangeDN = LegacyDN.GenerateLegacyDN(parentLegacyDN, dataObject, true, new LegacyDN.LegacyDNIsUnique(this.LegacyDNIsUnique)); } AcceptedDomain defaultAcceptedDomain = this.ConfigurationSession.GetDefaultAcceptedDomain(); if (defaultAcceptedDomain == null) { base.WriteError(new InvalidOperationException(Strings.ErrorNoDefaultAcceptedDomainFound(base.CurrentOrganizationId.ToString())), ErrorCategory.InvalidOperation, null); } dataObject.EmailAddresses.Add(new SmtpProxyAddress(dataObject.Alias + "@" + defaultAcceptedDomain.DomainName.Domain.ToString(), true)); dataObject.DeliverToMailboxAndForward = false; dataObject.OrganizationId = base.CurrentOrganizationId; }
public static EhfDomainItem CreateForOutboundOnlyTombstone(ExSearchResultEntry entry, EdgeSyncDiag diagSession) { EhfDomainItem ehfDomainItem = EhfDomainItem.CreateForTombstone(entry, diagSession); ehfDomainItem.Domain.Name = AcceptedDomain.FormatEhfOutboundOnlyDomainName(ehfDomainItem.Domain.Name, ehfDomainItem.Domain.DomainGuid.Value); return(ehfDomainItem); }
protected override void InternalProcessRecord() { TaskLogger.LogEnter(); if (this.TenantCU.OrganizationStatus == OrganizationStatus.PendingAcceptedDomainAddition || this.TenantCU.OrganizationStatus == OrganizationStatus.PendingAcceptedDomainRemoval) { OrganizationTaskHelper.SetOrganizationStatus(base.Session, this.TenantCU, OrganizationStatus.Active); } try { base.InternalProcessRecord(); } catch (Exception) { this.CleanupSecondaryDomain(); throw; } if (!base.HasErrors) { AcceptedDomain acceptedDomain = OrganizationTaskHelper.GetAcceptedDomain(AcceptedDomainIdParameter.Parse(this.Name), base.Session, new Task.TaskErrorLoggingDelegate(base.WriteError), true); base.WriteObject(acceptedDomain); } else { this.CleanupSecondaryDomain(); } TaskLogger.LogExit(); }
private void CheckForDuplicateExistingDomain() { AcceptedDomain acceptedDomain = OrganizationTaskHelper.GetAcceptedDomain(AcceptedDomainIdParameter.Parse(this.Name), base.Session, new Task.TaskErrorLoggingDelegate(base.WriteError), false); if (acceptedDomain != null) { base.WriteError(new ManagementObjectAlreadyExistsException(Strings.ErrorAcceptedDomainExists(this.Name)), ErrorCategory.ResourceExists, null); } }
private void CalculateProperties() { AcceptedDomainIdParameter defaultDomain = this.DefaultDomain; if (defaultDomain != null) { AcceptedDomain acceptedDomain = (AcceptedDomain)base.GetDataObject <AcceptedDomain>(defaultDomain, base.DataSession, this.RootId, new LocalizedString?(Strings.ErrorDefaultDomainNotFound(defaultDomain)), new LocalizedString?(Strings.ErrorDefaultDomainNotUnique(defaultDomain))); this.DataObject.DefaultDomain = acceptedDomain.Id; } }
public void SetAsGuidDomain() { if (this.domainCreatedWithGuid) { throw new InvalidOperationException(string.Format("Trying to set a Guid-Domain twice. DomainName: {0}", base.Domain.Name)); } base.Domain.Name = AcceptedDomain.FormatEhfOutboundOnlyDomainName(base.Domain.Name, base.GetDomainGuid()); base.Domain.Settings.DomainName = base.Domain.Name; this.domainCreatedWithGuid = true; }
protected override string GetDomainName() { string domainName = base.GetDomainName(); if (base.ADEntry.IsDeleted || !base.OutboundOnly) { return(domainName); } return(AcceptedDomain.FormatEhfOutboundOnlyDomainName(domainName, base.Domain.DomainGuid.Value)); }
protected override void InternalProcessRecord() { this.ProvisionSTS(); AcceptedDomain acceptedDomain = (AcceptedDomain)base.DataSession.Read <AcceptedDomain>(this.matchedAcceptedDomain.Id); acceptedDomain.FederatedOrganizationLink = this.DataObject.Id; acceptedDomain.PendingFederatedAccountNamespace = false; acceptedDomain.PendingFederatedDomain = false; base.DataSession.Save(acceptedDomain); }
private AcceptedDomain ResolveDefaultAcceptedDomain() { IConfigurationSession configurationSession = (IConfigurationSession)base.DataSession; AcceptedDomain defaultAcceptedDomain = configurationSession.GetDefaultAcceptedDomain(); if (defaultAcceptedDomain == null) { base.WriteError(new ManagementObjectNotFoundException(Strings.ErrorNoDefaultAcceptedDomainFound(configurationSession.SessionSettings.CurrentOrganizationId.ConfigurationUnit.ToString())), (ErrorCategory)1001, null); } return(defaultAcceptedDomain); }
public DomainSyncRecord(AcceptedDomain acceptedDomain) { if (acceptedDomain.OutboundOnly || acceptedDomain.PerimeterDuplicateDetected) { this.name = AcceptedDomain.FormatEhfOutboundOnlyDomainName(acceptedDomain.DomainName.Domain.Trim(), acceptedDomain.Guid).ToLower().Trim(); } else { this.name = acceptedDomain.DomainName.Domain.ToLower().Trim(); } this.guid = acceptedDomain.Guid; this.enabled = true; }
protected void ZapDanglingDomainTrusts() { foreach (ADObjectId identity in this.FederatedAcceptedDomains) { AcceptedDomain acceptedDomain = (AcceptedDomain)base.DataSession.Read <AcceptedDomain>(identity); if (acceptedDomain != null && acceptedDomain.FederatedOrganizationLink != null) { base.WriteVerbose(Strings.SetFedAcceptedDomainCleanup(acceptedDomain.DomainName.Domain)); acceptedDomain.FederatedOrganizationLink = null; base.DataSession.Save(acceptedDomain); } } }
private void CleanupSecondaryDomain() { AcceptedDomain acceptedDomain = OrganizationTaskHelper.GetAcceptedDomain(AcceptedDomainIdParameter.Parse(this.Name), base.Session, new Task.TaskErrorLoggingDelegate(base.WriteError), false); if (acceptedDomain != null) { try { base.Session.Delete(acceptedDomain); } catch (Exception ex) { this.WriteWarning(Strings.ErrorNonActiveOrganizationFound(ex.ToString())); } } }
private static IEnumerable <AcceptedDomain> FindConflictingDomains(IConfigurationSession session, AcceptedDomain oldDomain, AcceptedDomain newDomain) { List <QueryFilter> filters = new List <QueryFilter>(); filters.AddRange(AcceptedDomain.ConflictingDomainFilters(oldDomain, false)); filters.AddRange(AcceptedDomain.ConflictingDomainFilters(newDomain, false)); QueryFilter filter = new OrFilter(filters.ToArray()); ADPagedReader <AcceptedDomain> results = session.FindPaged <AcceptedDomain>(null, QueryScope.SubTree, filter, null, 0); foreach (AcceptedDomain result in results) { yield return(result); } yield return(newDomain); yield break; }
private static string GetDefaultAcceptedDomainName(OrganizationId organizationId) { string text; if (IrmUtils.DefaultAcceptedDomainTable.TryGetValue(organizationId, out text)) { return(text); } IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId), 375, "GetDefaultAcceptedDomainName", "f:\\15.00.1497\\sources\\dev\\Entities\\src\\Common\\DataProviders\\IrmUtils.cs"); AcceptedDomain defaultAcceptedDomain = tenantOrTopologyConfigurationSession.GetDefaultAcceptedDomain(); if (defaultAcceptedDomain != null) { text = defaultAcceptedDomain.DomainName.ToString(); } IrmUtils.DefaultAcceptedDomainTable.Add(organizationId, text); return(text); }
internal static void ValidateAssociatedAcceptedDomains(MultiValuedProperty <AcceptedDomainIdParameter> domainIdParameters, IConfigDataProvider dataSession, TenantInboundConnector dataObject, ObjectId rootId, Task task, Func <IIdentityParameter, IConfigDataProvider, ObjectId, LocalizedString?, LocalizedString?, IConfigurable> acceptedDomainsGetter) { if (domainIdParameters != null) { NewInboundConnector.ValidateCentralizedMailControlAndAssociatedAcceptedDomainsRestriction(dataSession, dataObject, task); dataObject.AssociatedAcceptedDomains.Clear(); using (MultiValuedProperty <AcceptedDomainIdParameter> .Enumerator enumerator = domainIdParameters.GetEnumerator()) { while (enumerator.MoveNext()) { AcceptedDomainIdParameter acceptedDomainIdParameter = enumerator.Current; AcceptedDomain acceptedDomain = (AcceptedDomain)acceptedDomainsGetter(acceptedDomainIdParameter, dataSession, rootId, new LocalizedString?(Strings.ErrorDefaultDomainNotFound(acceptedDomainIdParameter)), new LocalizedString?(Strings.ErrorDefaultDomainNotUnique(acceptedDomainIdParameter))); dataObject.AssociatedAcceptedDomains.Add(acceptedDomain.Id); } return; } } dataObject.AssociatedAcceptedDomains.Clear(); }
protected override void InternalValidate() { base.InternalValidate(); if (base.HasErrors) { return; } string message; if (!NewReceiveConnector.ValidataName(this.DataObject.Name, out message)) { base.WriteError(new ArgumentException(message), ErrorCategory.InvalidArgument, null); } if (base.Fields.IsModified("DefaultDomain")) { AcceptedDomainIdParameter defaultDomain = this.DefaultDomain; if (defaultDomain != null) { AcceptedDomain acceptedDomain = (AcceptedDomain)base.GetDataObject <AcceptedDomain>(defaultDomain, base.DataSession, this.RootId, new LocalizedString?(Strings.ErrorDefaultDomainNotFound(defaultDomain)), new LocalizedString?(Strings.ErrorDefaultDomainNotUnique(defaultDomain))); this.DataObject.DefaultDomain = acceptedDomain.Id; } else { this.DataObject.DefaultDomain = null; } } LocalizedException exception; if (!ReceiveConnectorNoMappingConflictCondition.Verify(this.DataObject, base.DataSession as IConfigurationSession, out exception)) { base.WriteError(exception, ErrorCategory.InvalidOperation, this.DataObject); } if (!this.serverObject.IsEdgeServer && (this.DataObject.AuthMechanism & AuthMechanisms.ExchangeServer) != AuthMechanisms.None && !ReceiveConnectorFqdnCondition.Verify(this.DataObject, this.serverObject, out exception)) { base.WriteError(exception, ErrorCategory.InvalidOperation, this.DataObject); } if (this.DataObject.AdvertiseClientSettings && (this.DataObject.PermissionGroups & PermissionGroups.ExchangeUsers) != PermissionGroups.ExchangeUsers) { base.WriteError(new AdvertiseClientSettingsWithoutExchangeUsersPermissionGroupsException(), ErrorCategory.InvalidOperation, this.DataObject); } }
// Token: 0x0600031F RID: 799 RVA: 0x00010E68 File Offset: 0x0000F068 public static bool ValidateDomainName(AcceptedDomain domain, Exception duplicateAcceptedDomainException, Exception conflictingAcceptedDomainException, out Exception error) { IConfigurationSession session; if (Globals.IsDatacenter) { try { session = DirectorySessionFactory.Default.CreateTenantConfigurationSession(ConsistencyMode.FullyConsistent, ADSessionSettings.FromTenantAcceptedDomain(domain.DomainName.Domain), 432, "ValidateDomainName", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\ADAccountPartitionLocator.cs"); goto IL_5C; } catch (CannotResolveTenantNameException) { error = null; return(true); } } session = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(ConsistencyMode.FullyConsistent, ADSessionSettings.FromRootOrgScopeSet(), 442, "ValidateDomainName", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\ADAccountPartitionLocator.cs"); IL_5C: return(ADAccountPartitionLocator.ValidateDomainName(domain, session, duplicateAcceptedDomainException, conflictingAcceptedDomainException, out error)); }
private void ProcessRemoveFederatedDomainRequest() { this.RemoveFederatedDomainFromSTS(); if (this.DomainName.Equals(this.DataObject.AccountNamespace) && !this.IsDatacenter) { string domain = this.DataObject.AccountNamespace.Domain; base.ZapDanglingDomainTrusts(); this.DataObject.AccountNamespace = null; this.DataObject.DelegationTrustLink = null; this.DataObject.Enabled = false; if (this.federationTrust != null && null != this.federationTrust.ApplicationUri) { string text = FederatedOrganizationId.RemoveHybridConfigurationWellKnownSubDomain(this.federationTrust.ApplicationUri.ToString()); if (text.Equals(domain, StringComparison.InvariantCultureIgnoreCase)) { this.federationTrust.ApplicationUri = null; this.federationTrust.ApplicationIdentifier = null; base.DataSession.Save(this.federationTrust); } } base.InternalProcessRecord(); return; } if (this.matchedAcceptedDomain != null && this.matchedAcceptedDomain.Id != null) { AcceptedDomain acceptedDomain = (AcceptedDomain)base.DataSession.Read <AcceptedDomain>(this.matchedAcceptedDomain.Id); if (acceptedDomain == null) { this.WriteWarning(Strings.ErrorDomainNameNotAcceptedDomain(this.DomainName.Domain)); return; } if (acceptedDomain.FederatedOrganizationLink == null) { this.WriteWarning(Strings.ErrorDomainIsNotFederated(this.DomainName.Domain)); return; } acceptedDomain.FederatedOrganizationLink = null; base.DataSession.Save(acceptedDomain); } }
private string GetDefaultDomain() { if (base.MyInvocation.MyCommand == null) { return(null); } string text = null; if (this.Recipients != null) { foreach (ProxyAddress proxyAddress in this.Recipients) { if (proxyAddress.Prefix == ProxyAddressPrefix.Smtp) { SmtpAddress smtpAddress = new SmtpAddress(proxyAddress.AddressString); text = smtpAddress.Domain; break; } } } if (text != null) { base.WriteVerbose(Strings.UsingDefaultDomainFromRecipient(text)); return(text); } IConfigurationSession configurationSession = this.GetConfigurationSession(); AcceptedDomain defaultAcceptedDomain = configurationSession.GetDefaultAcceptedDomain(); if (defaultAcceptedDomain != null) { text = defaultAcceptedDomain.DomainName.Domain; if (!string.IsNullOrEmpty(text)) { base.WriteVerbose(Strings.UsingDefaultDomainFromAD(text)); return(text); } } base.WriteVerbose(Strings.UnableToDiscoverDefaultDomain); return(null); }
internal static AcceptedDomain GetAcceptedDomain(AcceptedDomainIdParameter acceptedDomainId, IConfigurationSession adSession, Task.TaskErrorLoggingDelegate errorLogger, bool reportError) { AcceptedDomain result = null; IEnumerable <AcceptedDomain> objects = acceptedDomainId.GetObjects <AcceptedDomain>(null, adSession); using (IEnumerator <AcceptedDomain> enumerator = objects.GetEnumerator()) { if (enumerator.MoveNext()) { result = enumerator.Current; if (reportError && enumerator.MoveNext()) { errorLogger(new ManagementObjectAmbiguousException(Strings.ErrorSecondaryDomainNotUnique(acceptedDomainId.ToString())), ErrorCategory.InvalidArgument, null); } } else if (reportError) { errorLogger(new ManagementObjectNotFoundException(Strings.ErrorSecondaryDomainNotFound(acceptedDomainId.ToString())), ErrorCategory.InvalidArgument, null); } } return(result); }