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