internal NspiPrincipal NspiPrincipalFromLegacyDN(string legacyDN)
{
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.nspiPrincipal.OrganizationId);
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, this.nspiPrincipal.DirectorySearchRoot, CultureInfo.CurrentCulture.LCID, true, ConsistencyMode.IgnoreInvalid, null, sessionSettings, 584, "NspiPrincipalFromLegacyDN", "f:\\15.00.1497\\sources\\dev\\DoMT\\src\\Service\\RfriContext.cs");
tenantOrRootOrgRecipientSession.ServerTimeout = Configuration.ADTimeout;
try
{
ADUser aduser = tenantOrRootOrgRecipientSession.FindByLegacyExchangeDN(legacyDN) as ADUser;
if (aduser != null && !(bool)aduser[ADRecipientSchema.HiddenFromAddressListsValue])
{
return(NspiPrincipal.FromADUser(aduser));
}
}
catch (NonUniqueRecipientException)
{
RfriContext.ReferralTracer.TraceDebug <string>((long)this.ContextHandle, "NonUniqueRecipientException thrown for {0}", legacyDN);
}
catch (ObjectNotFoundException)
{
RfriContext.ReferralTracer.TraceDebug <string>((long)this.ContextHandle, "ObjectNotFoundException thrown: Couldn't find requested user for {0}", legacyDN);
}
catch (MailboxInfoStaleException)
{
RfriContext.ReferralTracer.TraceDebug <string>((long)this.ContextHandle, "MailboxInfoStaleException thrown for {0}", legacyDN);
}
catch (CannotGetSiteInfoException)
{
RfriContext.ReferralTracer.TraceDebug <string>((long)this.ContextHandle, "CannotGetSiteInfoException thrown for {0}", legacyDN);
}
return(null);
}
public MailboxSearchConfigurationProvider(ADObjectId discoverySystemMailboxId, string searchName, IDiscoverySearchDataProvider searchDataProvider, MailboxDiscoverySearch searchObject)
{
Util.ThrowIfNullOrEmpty(searchName, "searchName");
this.discoverySystemMailboxId = discoverySystemMailboxId;
if (discoverySystemMailboxId != null)
{
OrganizationId organizationId = this.ResolveOrganization(discoverySystemMailboxId);
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId);
if (organizationId.Equals(OrganizationId.ForestWideOrgId))
{
adsessionSettings = ADSessionSettings.RescopeToSubtree(adsessionSettings);
}
if (VariantConfiguration.InvariantNoFlightingSnapshot.Global.MultiTenancy.Enabled)
{
adsessionSettings.IncludeInactiveMailbox = true;
}
this.recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.PartiallyConsistent, adsessionSettings, 146, ".ctor", "f:\\15.00.1497\\sources\\dev\\EDiscovery\\src\\MailboxSearch\\Common\\MailboxSearchConfigurationProvider.cs");
}
this.SearchDataProvider = searchDataProvider;
if (this.SearchDataProvider == null)
{
this.SearchDataProvider = new DiscoverySearchDataProvider(this.DiscoverySystemMailboxUser.OrganizationId);
}
this.SearchObject = searchObject;
if (this.SearchObject == null)
{
this.SearchObject = this.SearchDataProvider.Find <MailboxDiscoverySearch>(searchName);
if (this.SearchObject == null)
{
Util.Tracer.TraceError <string>((long)this.GetHashCode(), "Unable to find SearchObject {0}", searchName);
throw new SearchObjectNotFoundException(Strings.UnableToFindSearchObject(searchName));
}
}
}
// Token: 0x060007D0 RID: 2000 RVA: 0x00019AD4 File Offset: 0x00017CD4
internal static IConfigurationSession CreateADSystemConfigurationSession(bool readOnly, ConsistencyMode consistencyMode, UserContext userContext, IBudget budget)
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(userContext.ExchangePrincipal.MailboxInfo.OrganizationId);
adsessionSettings.AccountingObject = budget;
return(DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(readOnly, consistencyMode, adsessionSettings, 379, "CreateADSystemConfigurationSession", "f:\\15.00.1497\\sources\\dev\\clients\\src\\Owa2\\Server\\Core\\common\\UserContextUtilities.cs"));
}
private static IRecipientSession CreateADRecipientSession(int lcid, bool readOnly, ConsistencyMode consistencyMode, bool useDirectorySearchRoot, ExchangePrincipal exchangePrincipal, bool scopeToGal, ADObjectId directorySearchRoot)
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(exchangePrincipal.MailboxInfo.OrganizationId);
adsessionSettings.AccountingObject = null;
return(DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, useDirectorySearchRoot ? directorySearchRoot : null, lcid, readOnly, consistencyMode, null, adsessionSettings, 788, "CreateADRecipientSession", "f:\\15.00.1497\\sources\\dev\\clients\\src\\Owa2\\Server\\Core\\im\\InstantMessageUtilities.cs"));
}
public override void ConfigureProviders()
{
RequestStatisticsBase cachedRequestJob = base.MRSJob.CachedRequestJob;
PublicFolderRecipient localMailboxRecipient = this.publicFolderConfiguration.GetLocalMailboxRecipient(base.TargetMailboxGuid);
if (localMailboxRecipient == null)
{
throw new RecipientNotFoundPermanentException(base.TargetMailboxGuid);
}
List <MRSProxyCapabilities> list = new List <MRSProxyCapabilities>();
ProxyServerSettings proxyServerSettings = CommonUtils.MapDatabaseToProxyServer(localMailboxRecipient.Database.ObjectGuid);
list.Add(MRSProxyCapabilities.PublicFolderMigration);
IDestinationMailbox destinationMailbox = this.GetDestinationMailbox(localMailboxRecipient.Database.ObjectGuid, proxyServerSettings.ExtraFlags | LocalMailboxFlags.Move, list);
destinationMailbox.Config(base.MRSJob.GetReservation(localMailboxRecipient.Database.ObjectGuid, ReservationFlags.Write), base.TargetMailboxGuid, base.TargetMailboxGuid, CommonUtils.GetPartitionHint(cachedRequestJob.OrganizationId), localMailboxRecipient.Database.ObjectGuid, MailboxType.DestMailboxIntraOrg, null);
base.ConfigDestinationMailbox(destinationMailbox);
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.publicFolderConfiguration.OrganizationId);
this.orgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(false, ConsistencyMode.PartiallyConsistent, sessionSettings, 170, "ConfigureProviders", "f:\\15.00.1497\\sources\\dev\\mrs\\src\\Service\\PublicFolderMailboxMigrator.cs");
if (!CommonUtils.IsMultiTenantEnabled() && !base.Flags.HasFlag(MailboxCopierFlags.CrossOrg))
{
this.orgRecipientSession.EnforceDefaultScope = false;
this.orgRecipientSession.UseGlobalCatalog = true;
}
ArgumentValidator.ThrowIfNull("orgRecipientSession", this.orgRecipientSession);
}
private ADObjectId GetPolicyIdFromAD(OrganizationId key)
{
ExTraceGlobals.MobileDevicePolicyTracer.Information <OrganizationId>((long)this.GetHashCode(), "MobileDevicePolicyIdCacheByOrganization.GetPolicyFromAD({0})", key);
ADSessionSettings settings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(key);
IConfigurationSession session = this.GetConfigSession(settings);
ADObjectId rootId = session.GetOrgContainerId();
QueryFilter filter = new BitMaskAndFilter(MobileMailboxPolicySchema.MobileFlags, 4096UL);
SortBy sortBy = new SortBy(ADObjectSchema.WhenChanged, SortOrder.Descending);
ADObjectId policyId = null;
try
{
ADNotificationAdapter.RunADOperation(delegate()
{
MobileMailboxPolicy[] array = session.Find <MobileMailboxPolicy>(rootId, QueryScope.SubTree, filter, sortBy, 1);
if (array != null && array.Length > 0)
{
policyId = array[0].Id;
OrgIdADObjectWrapper key2 = new OrgIdADObjectWrapper(policyId, key);
if (!MobileDevicePolicyCache.Instance.Contains(key2))
{
MobileDevicePolicyData mobileDevicePolicyDataFromMobileMailboxPolicy = MobileDevicePolicyDataFactory.GetMobileDevicePolicyDataFromMobileMailboxPolicy(array[0]);
MobileDevicePolicyCache.Instance.TryAdd(key2, ref mobileDevicePolicyDataFromMobileMailboxPolicy);
}
}
});
}
catch (LocalizedException arg)
{
ExTraceGlobals.MobileDevicePolicyTracer.TraceError <OrganizationId, LocalizedException>((long)this.GetHashCode(), "MobileDevicePolicyIdCacheByOrganization.GetPolicyIdFromAD({0}) threw exception: {1}", key, arg);
throw;
}
ExTraceGlobals.MobileDevicePolicyTracer.Information <OrganizationId, ADObjectId>((long)this.GetHashCode(), "MobileDevicePolicyIdCacheByOrganization.GetPolicyFromAD({0}) returned: {1}", key, policyId);
return(policyId);
}
private IConfigurationSession CreateConfigurationSession()
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.organizationId);
adsessionSettings.AccountingObject = null;
return(DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(this.consistencyMode, adsessionSettings, 667, "CreateConfigurationSession", "f:\\15.00.1497\\sources\\dev\\AirSync\\src\\AirSync\\GalSearch\\ADABSession.cs"));
}
protected override IConfigDataProvider CreateSession()
{
OrganizationId organizationId = this.ResolveCurrentOrganization();
ADUser tenantArbitrationMailbox;
try
{
tenantArbitrationMailbox = AdminAuditLogHelper.GetTenantArbitrationMailbox(organizationId);
}
catch (ObjectNotFoundException innerException)
{
TaskLogger.Trace("ObjectNotFoundException occurred when getting Exchange principal from the arbitration mailbox.", new object[0]);
throw new AuditLogSearchArbitrationMailboxNotFoundException(organizationId.ToString(), innerException);
}
catch (NonUniqueRecipientException innerException2)
{
TaskLogger.Trace("More than one tenant arbitration mailbox found for the current organization.", new object[0]);
throw new AuditLogSearchNonUniqueArbitrationMailboxFoundException(organizationId.ToString(), innerException2);
}
ExchangePrincipal principal = ExchangePrincipal.FromADUser(ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId), tenantArbitrationMailbox, RemotingOptions.AllowCrossSite);
ADSessionSettings sessionSettings = base.CurrentOrganizationId.ToADSessionSettings();
this.recipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(true, ConsistencyMode.FullyConsistent, sessionSettings, 310, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\AuditLogSearch\\NewAuditLogSearch.cs");
return(this.InternalCreateSearchDataProvider(principal, organizationId));
}
private IRecipientSession CreateRecipientSession()
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.organizationId);
adsessionSettings.AccountingObject = null;
return(DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, this.searchRoot, this.lcid, true, this.consistencyMode, null, adsessionSettings, 614, "CreateRecipientSession", "f:\\15.00.1497\\sources\\dev\\AirSync\\src\\AirSync\\GalSearch\\ADABSession.cs"));
}
protected override IConfigDataProvider CreateSession()
{
this.ResolveCurrentOrganization();
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.organizationId);
return(DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, true, ConsistencyMode.PartiallyConsistent, sessionSettings, 141, "CreateSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\transport\\UnifiedPolicy\\Tasks\\NewCompliancePolicySyncNotification.cs"));
}
// Token: 0x06000870 RID: 2160 RVA: 0x0001BA88 File Offset: 0x00019C88
private PolicyConfiguration GetPolicyFromAD(OrgIdADObjectWrapper key)
{
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(key.OrgId);
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(true, ConsistencyMode.FullyConsistent, sessionSettings, 89, "GetPolicyFromAD", "f:\\15.00.1497\\sources\\dev\\clients\\src\\Owa2\\Server\\Core\\configuration\\OwaMailboxPolicyCache.cs");
return(PolicyConfiguration.GetPolicyConfigurationFromAD(tenantOrTopologyConfigurationSession, key.AdObject));
}
private void InitializeADUserIfNeeded()
{
if (this.adUserInitialized)
{
return;
}
SecurityIdentifier userSid = this.clientSecurityContext.UserSid;
base.CheckOverBudget();
ADSessionSettings sessionSettings;
if (this.organizationId != null)
{
sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.organizationId);
}
else
{
sessionSettings = ADSessionSettings.FromRootOrgScopeSet();
}
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.FullyConsistent, sessionSettings, 397, "InitializeADUserIfNeeded", "f:\\15.00.1497\\sources\\dev\\infoworker\\src\\common\\RequestDispatch\\InternalClientContext.cs");
if (base.Budget != null)
{
tenantOrRootOrgRecipientSession.SessionSettings.AccountingObject = base.Budget;
}
this.adUser = (tenantOrRootOrgRecipientSession.FindBySid(userSid) as ADUser);
InternalClientContext.Tracer.TraceDebug((long)this.GetHashCode(), "{0}: {1}: found internal caller by SID {2} in the AD. User is {3}", new object[]
{
TraceContext.Get(),
this,
userSid,
this.adUser
});
this.adUserInitialized = true;
}
public static string GetOrganizationRealm(OrganizationId organizationId)
{
if (organizationId == null)
{
throw new ArgumentNullException("organizationId");
}
if (OAuthConfigHelper.isMultiTenancyEnabled && organizationId.Equals(OrganizationId.ForestWideOrgId))
{
throw new InvalidOperationException("Should not query the global Realm property in a Datacenter or Hosting deployement.");
}
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId);
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, sessionSettings, 53, "GetOrganizationRealm", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\SystemConfiguration\\OAuth\\OAuthConfigHelper.cs");
string result;
if (OAuthConfigHelper.isMultiTenancyEnabled)
{
OrganizationId currentOrganizationId = tenantOrTopologyConfigurationSession.SessionSettings.CurrentOrganizationId;
ExchangeConfigurationUnit exchangeConfigurationUnit = tenantOrTopologyConfigurationSession.Read <ExchangeConfigurationUnit>(currentOrganizationId.ConfigurationUnit);
result = exchangeConfigurationUnit.ExternalDirectoryOrganizationId;
}
else
{
AuthConfig authConfig = AuthConfig.Read(tenantOrTopologyConfigurationSession);
if (!string.IsNullOrEmpty(authConfig.Realm))
{
result = authConfig.Realm;
}
else
{
result = tenantOrTopologyConfigurationSession.GetDefaultAcceptedDomain().DomainName.ToString();
}
}
return(result);
}
public SearchWorkDefinition ParseSearch(ComplianceMessage target, SearchWorkDefinition definition)
{
QueryFilter queryFilter = null;
string query = definition.Query;
CultureInfo culture;
FaultDefinition faultDefinition;
ExceptionHandler.Parser.TryRun(delegate
{
if (string.IsNullOrEmpty(target.Culture))
{
culture = CultureInfo.InvariantCulture;
}
else
{
culture = CultureInfo.GetCultureInfo(target.Culture);
}
Func <IRecipientResolver, IPolicyTagProvider, QueryFilter> func = null;
switch (definition.Parser)
{
case SearchWorkDefinition.QueryParser.KQL:
func = ((IRecipientResolver r, IPolicyTagProvider p) => KqlParser.ParseAndBuildQuery(query, KqlParser.ParseOption.EDiscoveryMode, culture, r, p));
break;
case SearchWorkDefinition.QueryParser.AQS:
func = delegate(IRecipientResolver r, IPolicyTagProvider p)
{
AqsParser.ParseOption parseOption = AqsParser.ParseOption.UseCiKeywordOnly | AqsParser.ParseOption.DisablePrefixMatch | AqsParser.ParseOption.AllowShortWildcards;
return(AqsParser.ParseAndBuildQuery(query, parseOption, culture, r, p));
};
break;
}
if (func != null)
{
OrganizationId scopingOrganizationId = null;
IPolicyTagProvider arg = null;
IRecipientResolver arg2 = null;
if (OrganizationId.TryCreateFromBytes(target.TenantId, Encoding.UTF8, out scopingOrganizationId))
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(scopingOrganizationId);
adsessionSettings.IncludeInactiveMailbox = true;
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.PartiallyConsistent, adsessionSettings, 146, "ParseSearch", "f:\\15.00.1497\\sources\\dev\\EDiscovery\\src\\TaskDistributionSystem\\ApplicationPlugins\\EDiscovery\\FastLocalSearchResultsProvider.cs");
arg2 = new FastLocalSearchResultsProvider.RecipientIdentityResolver(tenantOrRootOrgRecipientSession);
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, adsessionSettings, 149, "ParseSearch", "f:\\15.00.1497\\sources\\dev\\EDiscovery\\src\\TaskDistributionSystem\\ApplicationPlugins\\EDiscovery\\FastLocalSearchResultsProvider.cs");
arg = new PolicyTagAdProvider(tenantOrTopologyConfigurationSession);
}
queryFilter = func(arg2, arg);
}
if (queryFilter != null)
{
definition.Query = FqlQueryBuilder.ToFqlString(queryFilter, culture);
}
}, TimeSpan.FromMinutes(1.0), out faultDefinition, target, null, default(CancellationToken), null, "ParseSearch", "f:\\15.00.1497\\sources\\dev\\EDiscovery\\src\\TaskDistributionSystem\\ApplicationPlugins\\EDiscovery\\FastLocalSearchResultsProvider.cs", 102);
if (faultDefinition != null)
{
ExceptionHandler.FaultMessage(target, faultDefinition, true);
}
return(definition);
}
protected PublishedFolder(MailboxSession mailboxSession, StoreObjectId folderId) : this(folderId)
{
Util.ThrowOnNullArgument(mailboxSession, "mailboxSession");
this.mailboxSession = mailboxSession;
this.sid = mailboxSession.MailboxOwner.Sid;
this.disposeMailboxSession = false;
this.sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(mailboxSession.MailboxOwner.MailboxInfo.OrganizationId ?? OrganizationId.ForestWideOrgId);
}
// Token: 0x06000682 RID: 1666 RVA: 0x00031AA8 File Offset: 0x0002FCA8
private static TransportConfigContainer GetTenantTransportConfig(OrganizationId orgId, EHAQuotaWarningEnforcer enforcer)
{
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(orgId);
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.IgnoreInvalid, sessionSettings, 349, "GetTenantTransportConfig", "f:\\15.00.1497\\sources\\dev\\MailboxAssistants\\src\\assistants\\elc\\SysCleanupAssistant\\EHAQuotaWarningEnforcer.cs");
PerTenantTransportSettings perTenantTransportSettings = new PerTenantTransportSettings(orgId);
return(perTenantTransportSettings.ReadTransportConfig(tenantOrTopologyConfigurationSession));
}
internal static void LoadFoldersInOrg(OrganizationId orgId, List <ELCFolder> allFolders)
{
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(orgId);
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(false, ConsistencyMode.PartiallyConsistent, sessionSettings, 175, "LoadFoldersInOrg", "f:\\15.00.1497\\sources\\dev\\infoworker\\src\\common\\ELC\\AdFolderReader.cs");
ADPagedReader <ELCFolder> elcFolders = tenantOrTopologyConfigurationSession.FindPaged <ELCFolder>(null, QueryScope.SubTree, null, null, 0);
AdReader.Tracer.TraceDebug(0L, "Found ELCFolders in the AD.");
AdFolderReader.ExtractTheGoodFolders(elcFolders, allFolders);
}
private static ITenantConfigurationSession CreateWritableTenantSession(OrganizationId organizationId)
{
string ridMasterName = ForestTenantRelocationsCache.GetRidMasterName(organizationId.PartitionId);
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId, false);
adsessionSettings.RetiredTenantModificationAllowed = true;
adsessionSettings.TenantConsistencyMode = TenantConsistencyMode.IncludeRetiredTenants;
return(DirectorySessionFactory.Default.CreateTenantConfigurationSession(ridMasterName, false, ConsistencyMode.PartiallyConsistent, adsessionSettings, 541, "CreateWritableTenantSession", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Relocation\\SetTenantRelocationRequest.cs"));
}
private ExchangePrincipal GetExchangePrincipalForRecipient(MailRecipient recipient, DeliverableItem item, ICollection <CultureInfo> recipientLanguages, bool useCompletePrincipal)
{
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(recipient.MailItemScopeOrganizationId);
Guid databaseGuid = this.context.MbxTransportMailItem.DatabaseGuid;
ExchangePrincipal exchangePrincipal;
if (this.IsPublicFolderRecipient(item))
{
ADObjectId value = recipient.ExtendedProperties.GetValue <ADObjectId>("Microsoft.Exchange.Transport.DirectoryData.ContentMailbox", null);
StoreObjectId storeObjectId = null;
if (value == null || !StoreObjectId.TryParseFromHexEntryId(recipient.ExtendedProperties.GetValue <string>("Microsoft.Exchange.Transport.DirectoryData.EntryId", null), out storeObjectId))
{
throw new SmtpResponseException(AckReason.UnableToDetermineTargetPublicFolderMailbox, MessageAction.Reroute);
}
this.deliverToFolder = storeObjectId;
try
{
exchangePrincipal = ExchangePrincipal.FromDirectoryObjectId(DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(true, ConsistencyMode.IgnoreInvalid, adsessionSettings, 830, "GetExchangePrincipalForRecipient", "f:\\15.00.1497\\sources\\dev\\MailboxTransport\\src\\MailboxTransportDelivery\\StoreDriver\\DeliveryItem.cs"), value, RemotingOptions.LocalConnectionsOnly);
goto IL_14C;
}
catch (Microsoft.Exchange.Data.Storage.ObjectNotFoundException)
{
throw new SmtpResponseException(AckReason.PublicFolderMailboxNotFound, MessageAction.Reroute);
}
}
MailboxItem mailboxItem = item as MailboxItem;
if (mailboxItem == null)
{
throw new InvalidOperationException("Delivery to PFDBs is not supported in E15");
}
if (!useCompletePrincipal)
{
string legacyExchangeDN;
if (!recipient.ExtendedProperties.TryGetValue <string>("Microsoft.Exchange.Transport.MailRecipient.DisplayName", out legacyExchangeDN))
{
legacyExchangeDN = mailboxItem.LegacyExchangeDN;
}
exchangePrincipal = ExchangePrincipal.FromMailboxData(legacyExchangeDN, adsessionSettings, databaseGuid, mailboxItem.MailboxGuid, mailboxItem.LegacyExchangeDN, recipient.Email.ToString(), recipientLanguages ?? new MultiValuedProperty <CultureInfo>(), true, mailboxItem.RecipientType, mailboxItem.RecipientTypeDetails.GetValueOrDefault());
}
else
{
ProxyAddress proxyAddress = new SmtpProxyAddress((string)recipient.Email, true);
exchangePrincipal = ExchangePrincipal.FromProxyAddress(adsessionSettings, proxyAddress.ToString());
}
IL_14C:
if (exchangePrincipal.MailboxInfo.IsRemote)
{
throw new SmtpResponseException(AckReason.RecipientMailboxIsRemote, MessageAction.Reroute);
}
if (exchangePrincipal.MailboxInfo.Location == MailboxDatabaseLocation.Unknown)
{
throw new SmtpResponseException(AckReason.RecipientMailboxLocationInfoNotAvailable, MessageAction.Reroute);
}
return(exchangePrincipal);
}
// Token: 0x06000044 RID: 68 RVA: 0x000028C8 File Offset: 0x00000AC8
private IRecipientSession CreateRecipientSession()
{
if (OrganizationId.ForestWideOrgId == this.OrganizationId)
{
return(DirectorySessionFactory.Default.CreateRootOrgRecipientSession(null, null, LcidMapper.DefaultLcid, false, ConsistencyMode.IgnoreInvalid, null, ADSessionSettings.FromRootOrgScopeSet(), 472, "CreateRecipientSession", "f:\\15.00.1497\\sources\\dev\\assistants\\src\\AnchorService\\Common\\AnchorADProvider.cs"));
}
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.OrganizationId);
return(DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(this.preferredDomainController, null, LcidMapper.DefaultLcid, false, ConsistencyMode.IgnoreInvalid, null, sessionSettings, 485, "CreateRecipientSession", "f:\\15.00.1497\\sources\\dev\\assistants\\src\\AnchorService\\Common\\AnchorADProvider.cs"));
}
protected override TenantInfoProvider CreateOnCacheMiss(Guid key, ref bool shouldAdd)
{
OrganizationId scopingOrganizationId = OrganizationId.FromExternalDirectoryOrganizationId(key);
ADSessionSettings adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(scopingOrganizationId);
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, true, ConsistencyMode.PartiallyConsistent, adsessionSettings, 99, "CreateOnCacheMiss", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\UnifiedPolicy\\TenantInfoProviderFactory.cs");
ADUser discoveryMailbox = MailboxDataProvider.GetDiscoveryMailbox(tenantOrRootOrgRecipientSession);
ExchangePrincipal syncMailboxPrincipal = ExchangePrincipal.FromADUser(adsessionSettings, discoveryMailbox);
return(new TenantInfoProvider(syncMailboxPrincipal));
}
internal UnifiedGroupADAccessLayer(ADUser groupMailbox, string preferredDC)
{
if (groupMailbox.RecipientDisplayType == null || groupMailbox.RecipientDisplayType != RecipientDisplayType.GroupMailboxUser)
{
throw new InvalidOperationException("Update membership is only allowed on GroupMailbox. Recipient type:" + groupMailbox.RecipientDisplayType);
}
this.groupMailbox = groupMailbox;
this.preferredDC = preferredDC;
this.sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.groupMailbox.OrganizationId);
}
protected override TeamMailboxSyncInfo CreateOnCacheMiss(TeamMailboxSyncId key, ref bool shouldAdd)
{
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(key.DomainController, true, ConsistencyMode.PartiallyConsistent, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(key.OrgId), 105, "CreateOnCacheMiss", "f:\\15.00.1497\\sources\\dev\\data\\src\\storage\\LinkedFolder\\TeamMailboxSyncInfoCache.cs");
ADRecipient adrecipient = tenantOrRootOrgRecipientSession.FindByExchangeGuid(key.MailboxGuid);
ADUser aduser = adrecipient as ADUser;
if (aduser == null)
{
return(null);
}
TeamMailboxLifecycleState teamMailboxLifecycleState = TeamMailboxLifecycleState.Active;
if (TeamMailbox.IsPendingDeleteSiteMailbox(aduser))
{
teamMailboxLifecycleState = TeamMailboxLifecycleState.PendingDelete;
}
else if (aduser.SharePointUrl == null)
{
teamMailboxLifecycleState = TeamMailboxLifecycleState.Unlinked;
}
ExchangePrincipal exchangePrincipal = null;
try
{
exchangePrincipal = ExchangePrincipal.FromMailboxGuid(ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(key.OrgId), key.MailboxGuid, key.DomainController);
}
catch (ObjectNotFoundException)
{
return(null);
}
TeamMailboxSyncInfo result;
using (DisposeGuard disposeGuard = default(DisposeGuard))
{
MailboxSession mailboxSession = null;
UserConfiguration userConfiguration = null;
if (teamMailboxLifecycleState == TeamMailboxLifecycleState.Active)
{
mailboxSession = MailboxSession.OpenAsAdmin(exchangePrincipal, CultureInfo.InvariantCulture, "Client=TeamMailbox;Action=CommitChanges;Interactive=False");
disposeGuard.Add <MailboxSession>(mailboxSession);
if (!string.Equals(mailboxSession.MailboxOwner.MailboxInfo.Location.ServerFqdn, TeamMailboxSyncInfoCache.LocalServerFqdn, StringComparison.OrdinalIgnoreCase))
{
throw new WrongServerException(new LocalizedString(string.Format("Non-local XSO MailboxSession not allowed for TeamMailboxSync. TeamMailbox Name: {0}, MailboxGuid {1}, ServerFqdn {2}", mailboxSession.MailboxOwner.MailboxInfo.DisplayName, mailboxSession.MailboxOwner.MailboxInfo.MailboxGuid, mailboxSession.MailboxOwner.MailboxInfo.Location.ServerFqdn)));
}
userConfiguration = UserConfigurationHelper.GetMailboxConfiguration(mailboxSession, this.syncLogConfigurationName, UserConfigurationTypes.Stream, true);
disposeGuard.Add <UserConfiguration>(userConfiguration);
}
TeamMailbox teamMailbox = TeamMailbox.FromDataObject(aduser);
TeamMailboxSyncInfo teamMailboxSyncInfo = new TeamMailboxSyncInfo(key.MailboxGuid, teamMailboxLifecycleState, mailboxSession, exchangePrincipal, teamMailbox.DisplayName, teamMailbox.WebCollectionUrl, teamMailbox.WebId, (aduser.SharePointUrl != null) ? aduser.SharePointUrl.AbsoluteUri : null, (teamMailboxLifecycleState == TeamMailboxLifecycleState.Active) ? this.resourceMonitorFactory.Create(exchangePrincipal.MailboxInfo.MailboxDatabase.ObjectGuid) : null, userConfiguration);
disposeGuard.Success();
result = teamMailboxSyncInfo;
}
return(result);
}
private void CreatePartitionAllTenantsOrRootOrgGlobalCatalogSession()
{
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(base.CurrentOrganizationId);
bool flag = TaskHelper.ShouldPassDomainControllerToSession(this.DomainController, sessionSettings);
this.partitionOrRootOrgGlobalCatalogSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(flag ? this.DomainController : null, null, CultureInfo.CurrentCulture.LCID, true, ConsistencyMode.PartiallyConsistent, string.IsNullOrEmpty(this.DomainController) ? null : (flag ? this.NetCredential : null), sessionSettings, 450, "CreatePartitionAllTenantsOrRootOrgGlobalCatalogSession", "f:\\15.00.1497\\sources\\dev\\Configuration\\src\\ObjectModel\\BaseTasks\\DataAccessTask.cs");
if (!this.partitionOrRootOrgGlobalCatalogSession.IsReadConnectionAvailable())
{
this.partitionOrRootOrgGlobalCatalogSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(ConsistencyMode.PartiallyConsistent, sessionSettings, 461, "CreatePartitionAllTenantsOrRootOrgGlobalCatalogSession", "f:\\15.00.1497\\sources\\dev\\Configuration\\src\\ObjectModel\\BaseTasks\\DataAccessTask.cs");
}
this.partitionOrRootOrgGlobalCatalogSession.UseGlobalCatalog = true;
}
// Token: 0x0600009D RID: 157 RVA: 0x00004E80 File Offset: 0x00003080
public static void ResolveCaller()
{
IIdentity identity = HttpContext.Current.User.Identity;
if (!(identity is WindowsIdentity) && !(identity is ClientSecurityContextIdentity))
{
return;
}
try
{
RequestDetailsLoggerBase <RequestDetailsLogger> .Current.TrackLatency(ServiceLatencyMetadata.CallerADLatency, delegate()
{
DateTime utcNow = DateTime.UtcNow;
OrganizationId organizationId = (OrganizationId)HttpContext.Current.Items["UserOrganizationId"];
ADSessionSettings adsessionSettings;
if (organizationId != null)
{
adsessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId);
RequestDetailsLoggerBase <RequestDetailsLogger> .Current.AppendGenericInfo("ADSessionSettingsFromOrgId", (DateTime.UtcNow - utcNow).TotalMilliseconds);
}
else
{
string memberName = HttpContext.Current.GetMemberName();
if (string.IsNullOrEmpty(memberName) && identity is SidBasedIdentity)
{
memberName = (identity as SidBasedIdentity).MemberName;
}
adsessionSettings = Common.SessionSettingsFromAddress(memberName);
RequestDetailsLoggerBase <RequestDetailsLogger> .Current.AppendGenericInfo("ADSessionSettingsFromAddress", (DateTime.UtcNow - utcNow).TotalMilliseconds);
}
HttpContext.Current.Items["ADSessionSettings"] = adsessionSettings;
utcNow = DateTime.UtcNow;
IRecipientSession tenantOrRootOrgRecipientSession = DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(true, ConsistencyMode.IgnoreInvalid, adsessionSettings, 989, "ResolveCaller", "f:\\15.00.1497\\sources\\dev\\autodisc\\src\\Common\\Common.cs");
tenantOrRootOrgRecipientSession.ServerTimeout = new TimeSpan?(Common.RecipientLookupTimeout);
ADRecipient adrecipient = tenantOrRootOrgRecipientSession.FindBySid(identity.GetSecurityIdentifier());
RequestDetailsLoggerBase <RequestDetailsLogger> .Current.AppendGenericInfo("ADRecipientSessionFindBySid", (DateTime.UtcNow - utcNow).TotalMilliseconds);
if (adrecipient != null)
{
ExTraceGlobals.FrameworkTracer.TraceDebug <ObjectId>(0L, "ResolveCaller -- Resolved caller is {0}.", adrecipient.Identity);
}
HttpContext.Current.Items["CallerRecipient"] = adrecipient;
ADUser aduser = adrecipient as ADUser;
if (aduser != null && aduser.NetID != null)
{
HttpContext.Current.Items["PassportUniqueId"] = aduser.NetID.ToString();
}
});
}
catch (NonUniqueRecipientException)
{
ExTraceGlobals.FrameworkTracer.TraceError <string>(0L, "ResolveCaller -- InternalResolveCaller returned non-unique user for {0}.", identity.Name);
}
}
public static string GetTenantId(OrganizationId organizationId)
{
if (!Datacenter.IsMultiTenancyEnabled())
{
return(null);
}
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId);
ITenantConfigurationSession tenantConfigurationSession = DirectorySessionFactory.Default.CreateTenantConfigurationSession(true, ConsistencyMode.IgnoreInvalid, sessionSettings, 94, "GetTenantId", "f:\\15.00.1497\\sources\\dev\\data\\src\\directory\\SystemConfiguration\\OAuth\\OAuthConfigHelper.cs");
ExchangeConfigurationUnit exchangeConfigurationUnit = tenantConfigurationSession.Read <ExchangeConfigurationUnit>(organizationId.ConfigurationUnit);
return(exchangeConfigurationUnit.ExternalDirectoryOrganizationId);
}
internal static List <AdFolderData> GetUserElcFolders(MailboxSession session, ADUser aduser, List <ELCFolder> allAdFolders, bool getFoldersOnly, bool getOrgFoldersOnly)
{
if (allAdFolders == null || allAdFolders.Count == 0 || aduser == null)
{
return(null);
}
string arg = session.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString();
ADSessionSettings sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(session.MailboxOwner.MailboxInfo.OrganizationId);
IConfigurationSession tenantOrTopologyConfigurationSession = DirectorySessionFactory.Default.GetTenantOrTopologyConfigurationSession(ConsistencyMode.FullyConsistent, sessionSettings, 258, "GetUserElcFolders", "f:\\15.00.1497\\sources\\dev\\infoworker\\src\\common\\ELC\\AdFolderReader.cs");
ADObjectId managedFolderMailboxPolicy = aduser.ManagedFolderMailboxPolicy;
if (managedFolderMailboxPolicy == null)
{
AdReader.Tracer.TraceDebug <string>(0L, "Mailbox '{0}' does not have an ELC Mailbox policy.", arg);
return(null);
}
ManagedFolderMailboxPolicy managedFolderMailboxPolicy2 = tenantOrTopologyConfigurationSession.Read <ManagedFolderMailboxPolicy>(managedFolderMailboxPolicy);
if (managedFolderMailboxPolicy2 == null)
{
AdReader.Tracer.TraceDebug <string, ADObjectId>(0L, "Mailbox '{0}' no matching ELC Mailbox policy for Template '{1}'.", arg, managedFolderMailboxPolicy);
return(null);
}
MultiValuedProperty <ADObjectId> managedFolderLinks = managedFolderMailboxPolicy2.ManagedFolderLinks;
List <AdFolderData> list = new List <AdFolderData>();
using (MultiValuedProperty <ADObjectId> .Enumerator enumerator = managedFolderLinks.GetEnumerator())
{
while (enumerator.MoveNext())
{
ADObjectId elcFolderId = enumerator.Current;
ELCFolder elcfolder = allAdFolders.Find((ELCFolder adFolder) => elcFolderId.ObjectGuid == adFolder.Id.ObjectGuid);
if (elcfolder == null)
{
throw new ELCNoMatchingOrgFoldersException(elcFolderId.DistinguishedName);
}
if (!getOrgFoldersOnly || elcfolder.FolderType == ElcFolderType.ManagedCustomFolder)
{
AdFolderData adFolderData = new AdFolderData();
adFolderData.LinkedToTemplate = true;
adFolderData.Synced = false;
adFolderData.Folder = elcfolder;
if (!getFoldersOnly)
{
adFolderData.FolderSettings = AdFolderReader.FetchFolderContentSettings(elcfolder);
}
list.Add(adFolderData);
}
}
}
return(list);
}
// Token: 0x0600142A RID: 5162 RVA: 0x00048BF8 File Offset: 0x00046DF8
private IRecipientSession GetRecipientSession()
{
ADSessionSettings sessionSettings;
if (this.exchangePrincipal.MailboxInfo.Configuration.AddressBookPolicy != null)
{
sessionSettings = ADSessionSettings.FromOrganizationIdWithAddressListScopeServiceOnly(this.exchangePrincipal.MailboxInfo.OrganizationId, this.globalAddressListId);
}
else
{
sessionSettings = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(this.exchangePrincipal.MailboxInfo.OrganizationId);
}
return(DirectorySessionFactory.Default.GetTenantOrRootOrgRecipientSession(null, null, CultureInfo.CurrentCulture.LCID, true, ConsistencyMode.IgnoreInvalid, null, sessionSettings, 210, "GetRecipientSession", "f:\\15.00.1497\\sources\\dev\\clients\\src\\Owa2\\Server\\Core\\people\\AddressLists.cs"));
}
private static bool IsUserMemberOfTenant(string userAddress, OrganizationId organizationId)
{
bool result;
try
{
result = ServerManager.IsUserMemberOfTenant(userAddress, ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(organizationId));
}
catch (NonUniqueRecipientException ex)
{
throw new DirectoryServiceProviderException(false, "User email address is not unique: " + userAddress, ex);
}
return(result);
}
internal static ADSessionSettings GetSessionSettings(OrganizationId orgId, ProtocolLogger logger)
{
AirSyncDiagnostics.Assert(orgId != null);
if (GlobalSettings.IsMultiTenancyEnabled)
{
AirSyncDiagnostics.TraceDebug <string>(ExTraceGlobals.RequestsTracer, null, "organizationID :{0}", orgId.ToString());
ADSessionSettings result = null;
ADNotificationAdapter.RunADOperation(delegate()
{
result = ADSessionSettings.FromOrganizationIdWithoutRbacScopesServiceOnly(orgId);
});
return(result);
}
return(ADSessionSettings.FromRootOrgScopeSet());
}