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);
}
