public static IList GetAddedFederatedDomains(object originalAccountNS, object accountNS, object federatedDomains)
{
SmtpDomain rhs = originalAccountNS as SmtpDomain;
SmtpDomain smtpDomain = accountNS as SmtpDomain;
MultiValuedProperty <FederatedDomain> multiValuedProperty = federatedDomains as MultiValuedProperty <FederatedDomain>;
List <SmtpDomain> list = new List <SmtpDomain>();
if (multiValuedProperty != null && smtpDomain != null)
{
IList list2 = multiValuedProperty.Added;
if (!smtpDomain.Equals(rhs))
{
list2 = multiValuedProperty;
}
foreach (object obj in list2)
{
FederatedDomain federatedDomain = (FederatedDomain)obj;
if (!federatedDomain.Domain.Equals(smtpDomain))
{
list.Add(federatedDomain.Domain);
}
}
}
return(list.ToArray());
}
internal static Utils.EntryType ValidateAddressEntrySyntax(string address)
{
try
{
RoutingAddress.Parse(address);
return(Utils.EntryType.SmtpAddress);
}
catch (FormatException)
{
}
try
{
SmtpDomain.Parse(address);
return(Utils.EntryType.Domain);
}
catch (FormatException)
{
}
if (address == "*")
{
return(Utils.EntryType.WildCardedDomain);
}
if (address.StartsWith("*.") && address.Length > 2)
{
SmtpDomain.Parse(address.Substring(2, address.Length - 2));
return(Utils.EntryType.WildCardedDomain);
}
throw new FormatException(Strings.AddressRewriteUnrecognizedAddress);
}
public static IList GetRemovedFederatedDomains(object originalAccountNS, object accountNS, object federatedDomains)
{
SmtpDomain smtpDomain = originalAccountNS as SmtpDomain;
SmtpDomain objB = accountNS as SmtpDomain;
MultiValuedProperty <FederatedDomain> multiValuedProperty = federatedDomains as MultiValuedProperty <FederatedDomain>;
List <SmtpDomain> list = new List <SmtpDomain>();
if (multiValuedProperty != null && smtpDomain != null)
{
foreach (FederatedDomain federatedDomain in multiValuedProperty.Removed)
{
if (!federatedDomain.Domain.Equals(smtpDomain))
{
list.Add(federatedDomain.Domain);
}
}
if (!object.Equals(smtpDomain, objB))
{
foreach (FederatedDomain federatedDomain2 in multiValuedProperty)
{
if (!federatedDomain2.Domain.Equals(smtpDomain) && !WinformsHelper.FederatedDomainsContains(multiValuedProperty.Added, federatedDomain2.Domain))
{
list.Add(federatedDomain2.Domain);
}
}
list.Add(smtpDomain);
}
}
return(list.ToArray());
}
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);
}
public SyncConfig(SyncOrganization cu, SmtpDomain federatedNamespace, SmtpDomainWithSubdomains provisioningDomain) : base(cu)
{
if (cu == null)
{
throw new ArgumentNullException("The value of parameter cu is null!");
}
if (cu.FederatedTenant && federatedNamespace == null)
{
throw new ArgumentNullException("The value of parameter federatedNamespace should not be null for a federated organization!");
}
if (cu.ProvisioningDomain == null && provisioningDomain == null)
{
throw new ArgumentNullException("The value of parameter provisioningDomain is null!");
}
if (cu.FederatedTenant)
{
this.FederatedNamespace = federatedNamespace;
if (string.IsNullOrEmpty(this.FederatedIdentitySourceADAttribute))
{
this[SyncConfigSchema.FederatedIdentitySourceADAttribute] = "objectGuid";
}
}
else if (string.IsNullOrEmpty(this.PasswordFilePath))
{
this[SyncConfigSchema.PasswordFilePath] = "password.xml";
}
if (cu.ProvisioningDomain == null)
{
this[SyncConfigSchema.ProvisioningDomain] = provisioningDomain;
}
}
protected override void InternalProcessRecord()
{
GlobalLocatorServiceTenant globalLocatorServiceTenant = new GlobalLocatorServiceTenant();
GlobalLocatorServiceTenant oldGlsTenant = new GlobalLocatorServiceTenant();
GlsDirectorySession glsDirectorySession = new GlsDirectorySession();
if (base.Fields.IsModified("ExternalDirectoryOrganizationId"))
{
Guid guid = (Guid)base.Fields["ExternalDirectoryOrganizationId"];
if (!glsDirectorySession.TryGetTenantInfoByOrgGuid(guid, out oldGlsTenant))
{
base.WriteGlsTenantNotFoundError(guid);
}
}
else
{
SmtpDomain smtpDomain = (SmtpDomain)base.Fields["DomainName"];
if (!glsDirectorySession.TryGetTenantInfoByDomain(smtpDomain.Domain, out oldGlsTenant))
{
base.WriteGlsDomainNotFoundError(smtpDomain.Domain);
}
}
globalLocatorServiceTenant = this.GetUpdatedGLSTenant(oldGlsTenant);
glsDirectorySession.UpdateTenant(globalLocatorServiceTenant.ExternalDirectoryOrganizationId, globalLocatorServiceTenant.ResourceForest, globalLocatorServiceTenant.AccountForest, globalLocatorServiceTenant.SmtpNextHopDomain.Domain, globalLocatorServiceTenant.TenantFlags, globalLocatorServiceTenant.TenantContainerCN, globalLocatorServiceTenant.PrimarySite);
}
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();
}
public static void ExtractAccountNamespaceAndSharingDomains(DataRow row, DataTable dataTable, DataObjectStore store)
{
if (store.GetDataObject("FederatedOrganizationIdentifier") == null)
{
return;
}
FederatedOrganizationIdWithDomainStatus federatedOrganizationIdWithDomainStatus = (FederatedOrganizationIdWithDomainStatus)store.GetDataObject("FederatedOrganizationIdentifier");
SmtpDomain smtpDomain = (federatedOrganizationIdWithDomainStatus.AccountNamespace == null) ? null : new SmtpDomain(FederatedOrganizationId.RemoveHybridConfigurationWellKnownSubDomain(federatedOrganizationIdWithDomainStatus.AccountNamespace.Domain));
MultiValuedProperty <FederatedDomain> domains = federatedOrganizationIdWithDomainStatus.Domains;
dataTable.Rows[0]["HasAccountNamespace"] = false;
dataTable.Rows[0]["HasFederatedDomains"] = false;
if (smtpDomain != null)
{
List <object> list = new List <object>();
dataTable.Rows[0]["HasAccountNamespace"] = true;
dataTable.Rows[0]["Name"] = federatedOrganizationIdWithDomainStatus.AccountNamespace.Domain;
foreach (FederatedDomain federatedDomain in domains)
{
if (federatedDomain.Domain.Domain.Equals(smtpDomain.Domain, StringComparison.InvariantCultureIgnoreCase))
{
dataTable.Rows[0]["AccountNamespace"] = (SharingDomain)federatedDomain;
}
else
{
list.Add((SharingDomain)federatedDomain);
}
}
if (list.Count > 0)
{
dataTable.Rows[0]["SharingEnabledDomains"] = list;
dataTable.Rows[0]["HasFederatedDomains"] = true;
}
}
}
protected override void InternalProcessRecord()
{
GlsDirectorySession glsDirectorySession = new GlsDirectorySession();
Guid guid = Guid.Empty;
if (base.Fields.IsModified("ExternalDirectoryOrganizationId"))
{
guid = (Guid)base.Fields["ExternalDirectoryOrganizationId"];
GlobalLocatorServiceTenant globalLocatorServiceTenant;
if (!glsDirectorySession.TryGetTenantInfoByOrgGuid(guid, out globalLocatorServiceTenant))
{
base.WriteGlsTenantNotFoundError(guid);
}
}
else
{
SmtpDomain smtpDomain = (SmtpDomain)base.Fields["DomainName"];
GlobalLocatorServiceTenant globalLocatorServiceTenant;
if (!glsDirectorySession.TryGetTenantInfoByDomain(smtpDomain.Domain, out globalLocatorServiceTenant))
{
base.WriteGlsDomainNotFoundError(smtpDomain.Domain);
}
guid = globalLocatorServiceTenant.ExternalDirectoryOrganizationId;
}
glsDirectorySession.RemoveTenant(guid);
}
public bool TryFindMatchingDomain(SmtpDomain inputDomain, out SmtpDomain bestMatch, out bool isExactMatch)
{
if (inputDomain == null)
{
throw new ArgumentNullException("inputDomain");
}
return(GlobalConfigSession.TryFindMatchingDomainInternal(inputDomain, this.BloomFilterProvider, out bestMatch, out isExactMatch));
}
public FederatedDomainProof(SmtpDomain domainName, string name, string thumbprint, string proof)
{
this.DomainName = domainName;
this.Name = name;
this.Thumbprint = thumbprint;
this.Proof = proof;
this.DnsRecord = domainName + " TXT IN " + proof;
}
// Token: 0x06000C51 RID: 3153 RVA: 0x00037CB4 File Offset: 0x00035EB4
public IAsyncResult BeginDeleteDomain(SmtpDomain domain, Guid tenantId, Namespace ns, AsyncCallback callback, object asyncState)
{
DeleteDomainRequest deleteDomainRequest = LocatorServiceClientWriter.ConstructDeleteDomainRequest(domain, tenantId, ns);
LocatorService locatorService = this.AcquireServiceProxy();
IAsyncResult internalAsyncResult = locatorService.BeginDeleteDomain(this.requestIdentity, deleteDomainRequest, new AsyncCallback(LocatorServiceClientAdapter.OnWebServiceRequestCompleted), new GlsAsyncState(callback, asyncState, locatorService));
return(new GlsAsyncResult(callback, asyncState, locatorService, internalAsyncResult));
}
// Token: 0x06000C4D RID: 3149 RVA: 0x00037B60 File Offset: 0x00035D60
public void DeleteDomain(SmtpDomain domain, Guid tenantId, Namespace ns)
{
DeleteDomainRequest request = LocatorServiceClientWriter.ConstructDeleteDomainRequest(domain, tenantId, ns);
LocatorService proxy = this.AcquireServiceProxy();
GLSLogger.LoggingWrapper <DeleteDomainResponse>(this, domain.ToString(), proxy.GetHashCode().ToString(), () => proxy.DeleteDomain(this.requestIdentity, request));
base.ReleaseServiceProxy(proxy);
}
// Token: 0x06000C4F RID: 3151 RVA: 0x00037C18 File Offset: 0x00035E18
public IAsyncResult BeginSaveDomain(SmtpDomain domain, string domainKey, Guid tenantId, KeyValuePair <DomainProperty, PropertyValue>[] properties, AsyncCallback callback, object asyncState)
{
SaveDomainRequest saveDomainRequest = LocatorServiceClientWriter.ConstructSaveDomainRequest(domain, domainKey, tenantId, properties);
LocatorService locatorService = this.AcquireServiceProxy();
IAsyncResult internalAsyncResult = locatorService.BeginSaveDomain(this.requestIdentity, saveDomainRequest, new AsyncCallback(LocatorServiceClientAdapter.OnWebServiceRequestCompleted), new GlsAsyncState(callback, asyncState, locatorService));
return(new GlsAsyncResult(callback, asyncState, locatorService, internalAsyncResult));
}
// Token: 0x06000C4B RID: 3147 RVA: 0x00037A34 File Offset: 0x00035C34
public void SaveDomain(SmtpDomain domain, string domainKey, Guid tenantId, KeyValuePair <DomainProperty, PropertyValue>[] properties)
{
SaveDomainRequest request = LocatorServiceClientWriter.ConstructSaveDomainRequest(domain, domainKey, tenantId, properties);
LocatorService proxy = this.AcquireServiceProxy();
GLSLogger.LoggingWrapper <SaveDomainResponse>(this, domain.ToString(), proxy.GetHashCode().ToString(), () => proxy.SaveDomain(this.requestIdentity, request));
base.ReleaseServiceProxy(proxy);
}
public IAsyncResult BeginDomainExists(SmtpDomain domain, Namespace[] ns, AsyncCallback callback, object asyncState)
{
FindDomainRequest findDomainRequest = LocatorServiceClientReader.ConstructDomainExistsRequest(domain, ns, this.glsReadFlag);
LocatorService locatorService = this.AcquireServiceProxy();
IAsyncResult internalAsyncResult = locatorService.BeginFindDomain(this.requestIdentity, findDomainRequest, new AsyncCallback(LocatorServiceClientAdapter.OnWebServiceRequestCompleted), new GlsAsyncState(callback, asyncState, locatorService));
return(new GlsAsyncResult(callback, asyncState, locatorService, internalAsyncResult));
}
public SmtpDomainRow(SmtpDomain smtpDomain) : base(new Identity(smtpDomain.Domain, smtpDomain.Domain), null)
{
AutoDiscoverSmtpDomain autoDiscoverSmtpDomain = smtpDomain as AutoDiscoverSmtpDomain;
if (autoDiscoverSmtpDomain != null)
{
this.autodiscover = autoDiscoverSmtpDomain.AutoDiscover;
}
}
public override void OnAddFederatedDomain(SmtpDomain smtpDomain)
{
string domain = smtpDomain.ToString();
using (ManageDelegation1Client manageDelegation = this.GetManageDelegation())
{
base.AddUri(domain, base.ApplicationIdentifier, manageDelegation, Strings.ErrorManageDelegation1ProofDomainOwnership);
}
}
public override void OnRemoveFederatedDomain(SmtpDomain smtpDomain, bool force)
{
string uri = smtpDomain.ToString();
using (ManageDelegation1Client manageDelegation = this.GetManageDelegation())
{
base.RemoveUri(manageDelegation, uri, force);
}
}
public bool DomainExists(SmtpDomain domain, Namespace[] ns)
{
FindDomainRequest request = LocatorServiceClientReader.ConstructDomainExistsRequest(domain, ns, this.glsReadFlag);
LocatorService proxy = this.AcquireServiceProxy();
FindDomainResponse findDomainResponse = GLSLogger.LoggingWrapper <FindDomainResponse>(this, domain.ToString(), proxy.GetHashCode().ToString(), () => proxy.FindDomain(this.requestIdentity, request));
base.ReleaseServiceProxy(proxy);
return(findDomainResponse.DomainInfo != null);
}
public FindDomainResult FindDomain(SmtpDomain domain, DomainProperty[] domainProperties, TenantProperty[] tenantProperties)
{
FindDomainRequest request = LocatorServiceClientReader.ConstructFindDomainRequest(domain, domainProperties, tenantProperties, this.glsReadFlag);
LocatorService proxy = this.AcquireServiceProxy();
FindDomainResponse response = GLSLogger.LoggingWrapper <FindDomainResponse>(this, domain.ToString(), proxy.GetHashCode().ToString(), () => proxy.FindDomain(this.requestIdentity, request));
base.ReleaseServiceProxy(proxy);
return(LocatorServiceClientReader.ConstructFindDomainResult(response));
}
public OrganizationId Get(SmtpDomain smtpDomain)
{
if (smtpDomain == null)
{
throw new ArgumentNullException("smtpDomain");
}
SmtpDomainWithSubdomains smtpDomainWithSubdomain = new SmtpDomainWithSubdomains(smtpDomain, false);
return(this.Get(smtpDomainWithSubdomain));
}
internal ExchangeConfigurationUnit GetConfigurationUnit(string orgName)
{
if (string.IsNullOrEmpty(orgName))
{
throw new ArgumentException("OrgName must contain a non-empty value", "orgName");
}
ExchangeConfigurationUnit exchangeConfigurationUnit = null;
try
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromTenantCUName(orgName);
ITenantConfigurationSession tenantConfigurationSession = DirectorySessionFactory.Default.CreateTenantConfigurationSession(ConsistencyMode.PartiallyConsistent, adsessionSettings, 866, "GetConfigurationUnit", "f:\\15.00.1497\\sources\\dev\\Configuration\\src\\ObjectModel\\BaseTasks\\ADIdParameter.cs");
adsessionSettings.TenantConsistencyMode = TenantConsistencyMode.IncludeRetiredTenants;
exchangeConfigurationUnit = tenantConfigurationSession.GetExchangeConfigurationUnitByName(orgName);
}
catch (CannotResolveTenantNameException)
{
}
SmtpDomain smtpDomain = null;
if (exchangeConfigurationUnit == null && SmtpDomain.TryParse(orgName, out smtpDomain))
{
try
{
ADSessionSettings sessionSettings = ADSessionSettings.FromTenantAcceptedDomain(orgName);
ITenantConfigurationSession tenantConfigurationSession = DirectorySessionFactory.Default.CreateTenantConfigurationSession(ConsistencyMode.PartiallyConsistent, sessionSettings, 890, "GetConfigurationUnit", "f:\\15.00.1497\\sources\\dev\\Configuration\\src\\ObjectModel\\BaseTasks\\ADIdParameter.cs");
exchangeConfigurationUnit = tenantConfigurationSession.GetExchangeConfigurationUnitByNameOrAcceptedDomain(orgName);
}
catch (CannotResolveTenantNameException)
{
}
}
Guid externalDirectoryOrganizationId;
if (exchangeConfigurationUnit == null && GuidHelper.TryParseGuid(orgName, out externalDirectoryOrganizationId))
{
try
{
PartitionId partitionIdByExternalDirectoryOrganizationId = ADAccountPartitionLocator.GetPartitionIdByExternalDirectoryOrganizationId(externalDirectoryOrganizationId);
ADSessionSettings sessionSettings2 = ADSessionSettings.FromAllTenantsPartitionId(partitionIdByExternalDirectoryOrganizationId);
ITenantConfigurationSession tenantConfigurationSession = DirectorySessionFactory.Default.CreateTenantConfigurationSession(ConsistencyMode.PartiallyConsistent, sessionSettings2, 911, "GetConfigurationUnit", "f:\\15.00.1497\\sources\\dev\\Configuration\\src\\ObjectModel\\BaseTasks\\ADIdParameter.cs");
QueryFilter filter = new ComparisonFilter(ComparisonOperator.Equal, ExchangeConfigurationUnitSchema.ExternalDirectoryOrganizationId, externalDirectoryOrganizationId.ToString());
ExchangeConfigurationUnit[] array = tenantConfigurationSession.Find <ExchangeConfigurationUnit>(ADSession.GetConfigurationUnitsRoot(partitionIdByExternalDirectoryOrganizationId.ForestFQDN), QueryScope.SubTree, filter, null, 0);
if (array.Length == 1)
{
exchangeConfigurationUnit = array[0];
}
}
catch (CannotResolveExternalDirectoryOrganizationIdException)
{
}
}
return(exchangeConfigurationUnit);
}
public void BuildFilter(out string parameterList, out string filter, out string preArgs, DataRow row)
{
filter = null;
preArgs = null;
parameterList = null;
if (!DBNull.Value.Equals(row["IncludeDomainLocalFrom"]))
{
SmtpDomain item = (SmtpDomain)row["IncludeDomainLocalFrom"];
parameterList = string.Format("-IncludeDomainLocalFrom '{0}'", item.ToQuotationEscapedString());
}
}
private static HashSet <string> GetSearchableCertificates(IEnumerable <string> certificateFqdns)
{
HashSet <string> hashSet = new HashSet <string>();
if (certificateFqdns != null && certificateFqdns.Any <string>())
{
foreach (string text in certificateFqdns)
{
if (!string.IsNullOrWhiteSpace(text))
{
if (!hashSet.Contains(text))
{
hashSet.Add(text);
}
string text2 = string.Empty;
string text3 = string.Empty;
SmtpX509Identifier smtpX509Identifier;
SmtpDomain smtpDomain;
if (SmtpX509Identifier.TryParse(text, out smtpX509Identifier))
{
if (smtpX509Identifier != null && smtpX509Identifier.SubjectCommonName != null && smtpX509Identifier.SubjectCommonName.SmtpDomain != null)
{
text2 = smtpX509Identifier.SubjectCommonName.SmtpDomain.Domain;
}
}
else if (SmtpDomain.TryParse(text, out smtpDomain) && smtpDomain != null)
{
text2 = smtpDomain.Domain;
}
if (!string.IsNullOrWhiteSpace(text2))
{
int num = -1;
do
{
num = text2.IndexOf('.', num + 1);
if (num != -1)
{
if (!string.IsNullOrWhiteSpace(text3))
{
string item = "*." + text3;
if (!hashSet.Contains(item))
{
hashSet.Add(item);
}
}
text3 = text2.Substring(num + 1);
}
}while (num != -1);
}
}
}
}
return(hashSet);
}
public static OrganizationId ResolveOrganizationByRealm(string realm)
{
if (string.IsNullOrEmpty(realm))
{
throw new ArgumentNullException("realm");
}
OrganizationId result = null;
if (OAuthConfigHelper.isMultiTenancyEnabled)
{
try
{
Guid externalDirectoryOrganizationId;
ADSessionSettings adsessionSettings;
if (Guid.TryParse(realm, out externalDirectoryOrganizationId))
{
adsessionSettings = ADSessionSettings.FromExternalDirectoryOrganizationId(externalDirectoryOrganizationId);
}
else
{
SmtpDomain smtpDomain;
if (!SmtpDomain.TryParse(realm, out smtpDomain))
{
throw new RealmFormatInvalidException(DirectoryStrings.ErrorRealmFormatInvalid(realm));
}
adsessionSettings = ADSessionSettings.FromTenantAcceptedDomain(realm);
}
return(adsessionSettings.CurrentOrganizationId);
}
catch (CannotResolveExternalDirectoryOrganizationIdException innerException)
{
throw new RealmNotFoundException(DirectoryStrings.ErrorRealmNotFound(realm), innerException);
}
catch (CannotResolveTenantNameException innerException2)
{
throw new RealmNotFoundException(DirectoryStrings.ErrorRealmNotFound(realm), innerException2);
}
}
result = OrganizationId.ForestWideOrgId;
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 306, "ResolveOrganizationByRealm", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\SystemConfiguration\\OAuth\\OAuthConfigHelper.cs");
if (tenantOrTopologyConfigurationSession.GetAcceptedDomainByDomainName(realm) == null)
{
AuthConfig authConfig = AuthConfig.Read(tenantOrTopologyConfigurationSession);
if (!realm.Equals(authConfig.Realm))
{
if (OAuthConfigHelper.GetAuthServers().FirstOrDefault((AuthServer server) => realm.Equals(server.Realm, StringComparison.OrdinalIgnoreCase)) == null)
{
throw new RealmNotFoundException(DirectoryStrings.ErrorRealmNotFound(realm));
}
}
}
return(result);
}
private bool TaskConfigure(ITaskContext taskContext)
{
IOrganizationConfig organizationConfig = taskContext.TenantSession.GetOrganizationConfig();
if (organizationConfig.IsDehydrated)
{
try
{
taskContext.TenantSession.EnableOrganizationCustomization();
}
catch
{
}
}
if (this.RequiresFederationTrust())
{
if (this.updateOnPremisesFedOrgId)
{
IFederatedOrganizationIdentifier federatedOrganizationIdentifier = base.OnPremisesSession.GetFederatedOrganizationIdentifier();
string text = (federatedOrganizationIdentifier != null && federatedOrganizationIdentifier.DelegationTrustLink != null) ? federatedOrganizationIdentifier.DelegationTrustLink.ToString() : Configuration.FederatedTrustIdentity;
taskContext.OnPremisesSession.SetFederationTrustRefreshMetadata(text);
SmtpDomain autoDiscoverHybridDomain = this.AutoDiscoverHybridDomain;
string defaultDomain = (autoDiscoverHybridDomain != null && autoDiscoverHybridDomain.Domain != null) ? autoDiscoverHybridDomain.Domain : null;
taskContext.OnPremisesSession.SetFederatedOrganizationIdentifier(this.accountNamespace, text, defaultDomain);
}
List <Uri> acceptedTokenIssuerUris = taskContext.Parameters.Get <List <Uri> >("_onPremAcceptedTokenIssuerUris");
if (!OrganizationRelationshipTask.VerifyAcceptedTokenIssuerUri(base.OnPremisesSession, acceptedTokenIssuerUris))
{
throw new LocalizedException(HybridStrings.ErrorOnPremUsingConsumerLiveID);
}
acceptedTokenIssuerUris = taskContext.Parameters.Get <List <Uri> >("_tenantAcceptedTokenIssuerUris");
if (!OrganizationRelationshipTask.VerifyAcceptedTokenIssuerUri(base.TenantSession, acceptedTokenIssuerUris))
{
throw new LocalizedException(HybridStrings.ErrorTenantUsingConsumerLiveID);
}
if (this.updateTenantFedOrgId)
{
base.TenantSession.SetFederatedOrganizationIdentifier(this.TenantCoexistenceDomain);
}
foreach (string domainName in this.addOnPremisesFedDomains)
{
taskContext.OnPremisesSession.AddFederatedDomain(domainName);
}
}
OrganizationRelationship value = OrganizationRelationshipTask.ProvisionOrganizationRelationship(base.OnPremisesSession, taskContext.Parameters.Get <OrganizationRelationship>("_onPremOrgRel"), this.OnpremisesFederationInfo, new SmtpDomain[]
{
new SmtpDomain(this.TenantCoexistenceDomain)
}, TaskCommon.GetOnPremOrgRelationshipName(this.OnPremOrgConfig));
taskContext.Parameters.Set <OrganizationRelationship>("_onPremOrgRel", value);
value = OrganizationRelationshipTask.ProvisionOrganizationRelationship(base.TenantSession, taskContext.Parameters.Get <OrganizationRelationship>("_tenantOrgRel"), this.TenantFederationInfo, this.HybridDomains, TaskCommon.GetTenantOrgRelationshipName(this.OnPremOrgConfig));
taskContext.Parameters.Set <OrganizationRelationship>("_tenantOrgRel", value);
return(true);
}
public override void OnRemoveAccountNamespace(SmtpDomain smtpDomain, bool force)
{
LiveFederationProvision1.< > c__DisplayClass7 CS$ < > 8__locals1 = new LiveFederationProvision1.< > c__DisplayClass7();
CS$ < > 8__locals1.< > 4__this = this;
CS$ < > 8__locals1.domain = smtpDomain.ToString();
using (ManageDelegation1Client client = this.GetManageDelegation())
{
base.RemoveUri(client, CS$ < > 8__locals1.domain, force);
base.ReleaseDomain(CS$ < > 8__locals1.domain, base.ApplicationIdentifier, force, client, () => LiveFederationProvision1.GetDomainStateFromDomainInfo(client.GetDomainInfo(CS$ < > 8__locals1.< > 4__this.ApplicationIdentifier, CS$ < > 8__locals1.domain)));
}
}
internal FederationInformation(SmtpDomain identity, Uri targetApplicationUri, ICollection tokenIssuers, ICollection domainNames, Uri targetAutodiscoverEpr) : base(new FederationInformationPropertyBag())
{
this.propertyBag[FederationInformationSchema.Identity] = identity;
this.propertyBag[FederationInformationSchema.TargetApplicationUri] = targetApplicationUri;
this.propertyBag[FederationInformationSchema.DomainNames] = new MultiValuedProperty <SmtpDomain>(true, null, domainNames);
this.propertyBag[FederationInformationSchema.TargetAutodiscoverEpr] = targetAutodiscoverEpr;
if (tokenIssuers != null)
{
this.propertyBag[FederationInformationSchema.TokenIssuerUris] = new MultiValuedProperty <Uri>(true, null, tokenIssuers);
}
base.ResetChangeTracking(true);
}
protected override void InternalProcessRecord()
{
GlobalLocatorServiceDomain globalLocatorServiceDomain = new GlobalLocatorServiceDomain();
GlsDirectorySession glsDirectorySession = new GlsDirectorySession();
SmtpDomain smtpDomain = (SmtpDomain)base.Fields["DomainName"];
if (!glsDirectorySession.TryGetTenantDomainFromDomainFqdn(smtpDomain.Domain, out globalLocatorServiceDomain, true))
{
base.WriteGlsDomainNotFoundError(smtpDomain.Domain);
}
glsDirectorySession.RemoveAcceptedDomain(globalLocatorServiceDomain.ExternalDirectoryOrganizationId, smtpDomain.Domain, true);
}
