private PolicyTipsData ReadAggregatedPolicyTipsData(UserConfigurationManager.IAggregationContext ctx, OrganizationId organizationId)
{
return(UserContextUtilities.ReadAggregatedType <PolicyTipsData>(ctx, "OWA.PolicyTips", () => new PolicyTipsData
{
IsPolicyTipsEnabled = GetOwaUserConfiguration.IsPolicyTipsEnabled(organizationId)
}));
}
protected void SetUserConfigPropertiesFromOrganizationConfig(UserConfigurationManager.IAggregationContext ctx, OrganizationId organizationId, OwaUserConfiguration configuration)
{
OwaOrgConfigData owaOrgConfigData = this.ReadAggregatedOrgConfigData(ctx, organizationId);
configuration.MailTipsLargeAudienceThreshold = owaOrgConfigData.MailTipsLargeAudienceThreshold;
configuration.PublicComputersDetectionEnabled = owaOrgConfigData.PublicComputersDetectionEnabled;
}
private void RecordAggregationStats(UserConfigurationManager.IAggregationContext aggregation)
{
if (aggregation == null)
{
base.CallContext.ProtocolLog.Set(OwaUserConfigurationLogMetadata.AggregationStats, "NULL");
return;
}
int num = aggregation.FaiCacheHits + aggregation.TypeCacheHits;
int num2 = aggregation.FaiCacheMisses + aggregation.TypeCacheMisses;
int num3 = num + num2;
string value = string.Format("{0}:{1}::{2}:{3}", new object[]
{
aggregation.FaiCacheHits,
aggregation.FaiCacheMisses,
aggregation.TypeCacheHits,
aggregation.TypeCacheMisses
});
base.CallContext.ProtocolLog.Set(OwaUserConfigurationLogMetadata.AggregationStats, value);
if (num > 0)
{
OwaSingleCounters.AggregatedUserConfigurationPartsRead.IncrementBy((long)num);
}
if (num3 > 0)
{
OwaSingleCounters.AggregatedUserConfigurationPartsRequested.IncrementBy((long)num3);
}
}
private void CreateFeatureManagerFactoryFromMailbox(OWAMiniRecipient miniRecipient)
{
UserConfigurationManager.IAggregationContext aggregationContext = null;
try
{
this.LockAndReconnectMailboxSession();
aggregationContext = base.MailboxSession.UserConfigurationManager.AttachAggregator(AggregatedUserConfigurationSchema.Instance.OwaUserConfiguration);
base.UnlockAndDisconnectMailboxSession();
OwaFlightConfigData owaFlightConfigData = UserContext.ReadAggregatedFlightConfigData(aggregationContext, base.ExchangePrincipal.MailboxInfo.OrganizationId);
RecipientTypeDetails recipientTypeDetails = base.ExchangePrincipal.RecipientTypeDetails;
this.featuresManagerFactory = new FeaturesManagerFactory(miniRecipient, new ConfigurationContext(this), new ScopeFlightsSettingsProvider(), (VariantConfigurationSnapshot c) => new FeaturesStateOverride(c, recipientTypeDetails), owaFlightConfigData.RampId, owaFlightConfigData.IsFirstRelease);
}
finally
{
if (aggregationContext != null)
{
aggregationContext.Detach();
this.bootAggregationContext = aggregationContext;
}
if (base.MailboxSessionLockedByCurrentThread())
{
base.UnlockAndDisconnectMailboxSession();
}
}
}
private OwaHelpUrlData ReadAggregatedOwaHelpUrlData(UserConfigurationManager.IAggregationContext ctx, CultureInfo cultureInfo, OwaIdentity mailboxIdentity, UserAgent userAgent)
{
return(UserContextUtilities.ReadAggregatedType <OwaHelpUrlData>(ctx, "OWA.OwaHelpUrlData", delegate
{
HelpProvider.RenderingMode mode = HelpProvider.RenderingMode.Mouse;
switch (userAgent.Layout)
{
case LayoutType.TouchNarrow:
mode = HelpProvider.RenderingMode.TNarrow;
break;
case LayoutType.TouchWide:
mode = HelpProvider.RenderingMode.TWide;
break;
case LayoutType.Mouse:
mode = HelpProvider.RenderingMode.Mouse;
break;
}
OrganizationProperties organizationProperties = null;
if (mailboxIdentity != null)
{
organizationProperties = mailboxIdentity.UserOrganizationProperties;
}
string helpUrl = HelpProvider.ConstructHelpRenderingUrl(cultureInfo.LCID, HelpProvider.OwaHelpExperience.Premium, string.Empty, mode, null, organizationProperties).ToString();
return new OwaHelpUrlData
{
HelpUrl = helpUrl
};
}));
}
public ConfigurationContext(UserContext userContext, UserConfigurationManager.IAggregationContext aggregationContext)
{
this.principal = userContext.ExchangePrincipal;
this.allowedCapabilitiesFlags = userContext.AllowedCapabilitiesFlags;
this.MySiteUrl = ((userContext.MailboxIdentity == null) ? null : (userContext.MailboxIdentity.GetOWAMiniRecipient()[ADRecipientSchema.WebPage] as string));
this.aggregationContext = aggregationContext;
}
private UserConfigurationManager.IAggregationContext CreateAggregatedConfiguration(UserContext userContext, MailboxSession session)
{
UserConfigurationManager.IAggregationContext result = null;
if (userContext != null && !userContext.IsExplicitLogon && session != null && session.UserConfigurationManager != null)
{
ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "user configuration will create an aggregated user configuration.");
result = session.UserConfigurationManager.AttachAggregator(AggregatedUserConfigurationSchema.Instance.OwaUserConfiguration);
}
return(result);
}
private SmimeSettingsData ReadAggregatedSmimeData(UserConfigurationManager.IAggregationContext ctx, OrganizationId organizationId)
{
return(UserContextUtilities.ReadAggregatedType <SmimeSettingsData>(ctx, "OWA.SMIME", delegate
{
SmimeSettingsData result = null;
ISmimeSettingsProvider smimeSettingsProvider = SmimeAdminSettingsType.ReadSmimeSettingsFromAd(organizationId);
if (smimeSettingsProvider != null)
{
result = new SmimeSettingsData(SmimeAdminSettingsType.ReadSmimeSettingsFromAd(organizationId));
}
return result;
}));
}
public UserConfigurationManager.IAggregationContext AttachAggregator(UserConfigurationManager.IAggregationContext ictx)
{
UserConfigurationManager.AggregationContext aggregationContext = null;
if (ConfigurationItemSchema.IsEnabledForConfigurationAggregation(this.mailboxSession.MailboxOwner))
{
UserConfigurationManager.AggregationContext aggregationContext2 = ictx as UserConfigurationManager.AggregationContext;
if (aggregationContext2 == null)
{
throw new ArgumentException("The shared context must be non-null and have been created by a UserConfigurationManager");
}
aggregationContext = aggregationContext2.Clone(this);
lock (this.aggregators)
{
this.aggregators.Add(aggregationContext);
}
}
return(aggregationContext);
}
// Token: 0x06001C09 RID: 7177 RVA: 0x0006DD6C File Offset: 0x0006BF6C
protected override ValidateAggregatedConfigurationResponse InternalExecute()
{
ValidateAggregatedConfigurationResponse report = new ValidateAggregatedConfigurationResponse();
bool flag = false;
object obj = ValidateAggregatedConfiguration.RemoveFromValidationCache(base.MailboxIdentityMailboxSession);
bool flag2 = obj is bool && (bool)obj;
UserConfigurationManager.IAggregationContext aggregationContext = obj as UserConfigurationManager.IAggregationContext;
try
{
if (flag2)
{
flag = true;
ExTraceGlobals.SessionDataHandlerTracer.TraceDebug((long)this.GetHashCode(), "ValidateAggregatedConfiguration was invoked and the aggregator was recently validated.");
}
else if (aggregationContext != null)
{
aggregationContext.Validate(base.MailboxIdentityMailboxSession, delegate(IEnumerable <UserConfigurationDescriptor.MementoClass> faisRebuilt, IEnumerable <string> typesRebuilt)
{
foreach (UserConfigurationDescriptor.MementoClass mementoClass in faisRebuilt)
{
report.FaiUpdates.Add(mementoClass.ConfigurationName);
OwaSingleCounters.AggregatedUserConfigurationPartsRebuilt.Increment();
ExTraceGlobals.SessionDataHandlerTracer.TraceError <string>((long)this.GetHashCode(), "error found in configuration type {0}", mementoClass.ConfigurationName);
}
foreach (string item in typesRebuilt)
{
report.TypeUpdates.Add(item);
}
});
flag = true;
}
if (flag)
{
ValidateAggregatedConfiguration.AddToValidationCache(base.MailboxIdentityMailboxSession, true);
report.IsValidated = true;
}
}
finally
{
DisposeGuard.DisposeIfPresent(aggregationContext);
}
return(report);
}
private void ValidateAndDisposeAggregatedConfiguration(UserConfigurationManager.IAggregationContext aggregator, MailboxSession session)
{
bool flag = true;
try
{
if (aggregator != null)
{
aggregator.Detach();
if (!base.CallContext.HasDeviceHeaders)
{
ValidateAggregatedConfiguration.AddToValidationCache(session, aggregator);
flag = false;
}
else
{
flag = true;
ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "user configuration being requested by an offline action.");
object obj = ValidateAggregatedConfiguration.RemoveFromValidationCache(session);
bool flag2 = obj is bool && (bool)obj;
if (flag2)
{
ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "aggregated configuration was already validated during boot.");
}
else
{
DisposeGuard.DisposeIfPresent(obj as IDisposable);
ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "aggregated configuration was not validated during boot. validating now.");
aggregator.Validate(session, delegate(IEnumerable <UserConfigurationDescriptor.MementoClass> param0, IEnumerable <string> param1)
{
});
}
ValidateAggregatedConfiguration.AddToValidationCache(session, true);
}
}
}
finally
{
if (flag)
{
DisposeGuard.DisposeIfPresent(aggregator);
}
}
}
private UMSettingsData ReadAggregatedUMSettingsData(UserConfigurationManager.IAggregationContext ctx, ExchangePrincipal exchangePrincipal)
{
return(UserContextUtilities.ReadAggregatedType <UMSettingsData>(ctx, "OWA.UMSettings", delegate
{
UMSettingsData umsettingsData = new UMSettingsData();
try
{
using (UMClientCommon umclientCommon = new UMClientCommon(exchangePrincipal))
{
umsettingsData.PlayOnPhoneDialString = umclientCommon.GetPlayOnPhoneDialString();
umsettingsData.IsRequireProtectedPlayOnPhone = umclientCommon.IsRequireProtectedPlayOnPhone();
umsettingsData.IsUMEnabled = umclientCommon.IsUMEnabled();
}
}
catch (LocalizedException arg)
{
ExTraceGlobals.CoreTracer.TraceWarning <LocalizedException>((long)this.GetHashCode(), "Failed to initialize UM settings due to exception: {0}", arg);
}
return umsettingsData;
}));
}
private MobileDevicePolicyData ReadAggregatedMobileDevicePolicyData(UserConfigurationManager.IAggregationContext ctx, ExchangePrincipal principal)
{
return(UserContextUtilities.ReadAggregatedType <MobileDevicePolicyData>(ctx, "OWA.MobileDevicePolicy", () => MobileDevicePolicyDataFactory.GetPolicyData(principal)));
}
// Token: 0x06000805 RID: 2053 RVA: 0x0001A808 File Offset: 0x00018A08
internal static WacConfigData ReadAggregatedWacData(UserContext userContext, UserConfigurationManager.IAggregationContext ctx)
{
return(UserContextUtilities.ReadAggregatedType <WacConfigData>(ctx, "OWA.WacData", () => AttachmentPolicy.GetWacConfigData(userContext)));
}
internal UserConfigurationManager.IAggregationContext TryConsumeBootAggregation()
{
UserConfigurationManager.IAggregationContext comparand = this.bootAggregationContext;
return(Interlocked.CompareExchange <UserConfigurationManager.IAggregationContext>(ref this.bootAggregationContext, null, comparand));
}
protected override OwaUserConfiguration InternalExecute()
{
MailboxSession mailboxIdentityMailboxSession = base.MailboxIdentityMailboxSession;
UserContext userContext = UserContextManager.GetUserContext(CallContext.Current.HttpContext, CallContext.Current.EffectiveCaller, true);
UserConfigurationManager.IAggregationContext aggregationContext = null;
OwaUserConfiguration result;
try
{
if (!DefaultPageBase.IsRecoveryBoot(base.CallContext.HttpContext))
{
using (UserConfigurationManager.IAggregationContext aggregationContext2 = userContext.TryConsumeBootAggregation())
{
if (aggregationContext2 != null)
{
aggregationContext = mailboxIdentityMailboxSession.UserConfigurationManager.AttachAggregator(aggregationContext2);
}
else
{
aggregationContext = this.CreateAggregatedConfiguration(userContext, mailboxIdentityMailboxSession);
}
}
}
UserOptionsType userOptionsType = new UserOptionsType();
userOptionsType.Load(mailboxIdentityMailboxSession, true, true);
OwaUserConfiguration owaUserConfiguration = new OwaUserConfiguration();
owaUserConfiguration.UserOptions = userOptionsType;
string userAgent = CallContext.Current.HttpContext.Request.UserAgent;
UserAgent userAgent2 = new UserAgent(userAgent, userContext.FeaturesManager.ClientServerSettings.ChangeLayout.Enabled, base.CallContext.HttpContext.Request.Cookies);
StorePerformanceCountersCapture countersCapture = StorePerformanceCountersCapture.Start(mailboxIdentityMailboxSession);
UMSettingsData umSettings = this.ReadAggregatedUMSettingsData(aggregationContext, userContext.ExchangePrincipal);
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.UMClient, countersCapture, true);
owaUserConfiguration.SessionSettings = new SessionSettingsType(userContext, mailboxIdentityMailboxSession, userAgent2, base.CallContext, umSettings, this.ReadAggregatedOwaHelpUrlData(aggregationContext, Thread.CurrentThread.CurrentUICulture, userContext.MailboxIdentity, userAgent2));
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.SessionSettings, countersCapture, true);
ConfigurationContext configurationContext = new ConfigurationContext(userContext, aggregationContext);
string defaultTheme = configurationContext.DefaultTheme;
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.ConfigContext, countersCapture, true);
owaUserConfiguration.SegmentationSettings = new SegmentationSettingsType(configurationContext);
owaUserConfiguration.SegmentationSettings.InstantMessage &= !UserAgentUtilities.IsMonitoringRequest(userAgent);
owaUserConfiguration.SegmentationSettings.InstantMessage &= VdirConfiguration.Instance.InstantMessagingEnabled;
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.SegmentationSettings, countersCapture, true);
WacConfigData wacData = AttachmentPolicy.ReadAggregatedWacData(userContext, aggregationContext);
owaUserConfiguration.AttachmentPolicy = configurationContext.AttachmentPolicy.CreateAttachmentPolicyType(userContext, userAgent2, wacData);
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.AttachmentPolicy, countersCapture, true);
PolicySettingsType policySettingsType = new PolicySettingsType();
policySettingsType.PlacesEnabled = (this.placesConfigurationCache.IsFeatureEnabled && configurationContext.PlacesEnabled && !PlacesConfigurationCache.IsRestrictedCulture(owaUserConfiguration.SessionSettings.UserCulture));
policySettingsType.WeatherEnabled = (this.weatherConfigurationCache.IsFeatureEnabled && configurationContext.WeatherEnabled && !this.weatherConfigurationCache.IsRestrictedCulture(owaUserConfiguration.SessionSettings.UserCulture));
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.PlacesWeather, countersCapture, true);
policySettingsType.DefaultTheme = configurationContext.DefaultTheme;
policySettingsType.InstantMessagingType = configurationContext.InstantMessagingType;
policySettingsType.UseGB18030 = configurationContext.UseGB18030;
policySettingsType.UseISO885915 = configurationContext.UseISO885915;
policySettingsType.OutboundCharset = configurationContext.OutboundCharset;
policySettingsType.AllowCopyContactsToDeviceAddressBook = configurationContext.AllowCopyContactsToDeviceAddressBook;
policySettingsType.AllowOfflineOnString = configurationContext.AllowOfflineOn.ToString();
policySettingsType.MySiteUrl = configurationContext.MySiteUrl;
owaUserConfiguration.PolicySettings = policySettingsType;
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.PolicySettings, countersCapture, true);
owaUserConfiguration.MobileDevicePolicySettings = MobileDevicePolicyDataFactory.GetPolicySettings(this.ReadAggregatedMobileDevicePolicyData(aggregationContext, userContext.ExchangePrincipal));
owaUserConfiguration.ApplicationSettings = this.GetApplicationSettings();
owaUserConfiguration.ViewStateConfiguration = new OwaViewStateConfiguration();
owaUserConfiguration.ViewStateConfiguration.LoadAll(mailboxIdentityMailboxSession);
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.OwaViewStateConfiguration, countersCapture, true);
OrganizationId organizationId = mailboxIdentityMailboxSession.MailboxOwner.MailboxInfo.OrganizationId;
this.SetUserConfigPropertiesFromOrganizationConfig(aggregationContext, organizationId, owaUserConfiguration);
userContext.IsPublicLogon = (owaUserConfiguration.SessionSettings.IsPublicLogon || (owaUserConfiguration.PublicComputersDetectionEnabled && owaUserConfiguration.SessionSettings.IsPublicComputerSession));
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.GetMailTipsLargeAudienceThreshold, countersCapture, true);
owaUserConfiguration.RetentionPolicyTags = this.GetRetentionPolicyTags(mailboxIdentityMailboxSession);
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.GetRetentionPolicyTags, countersCapture, true);
try
{
owaUserConfiguration.MasterCategoryList = MasterCategoryListHelper.GetMasterCategoryListType(mailboxIdentityMailboxSession, base.CallContext.OwaCulture);
}
catch (QuotaExceededException ex)
{
ExTraceGlobals.UserContextCallTracer.TraceDebug <string>(0L, "GetOwaUserConfiguration: Get MasterCategoryList failed. Exception: {0}", ex.Message);
}
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.GetMasterCategoryListType, countersCapture, true);
owaUserConfiguration.MaxRecipientsPerMessage = this.GetMaxRecipientsPerMessage();
OwaUserConfigurationLogUtilities.LogAndResetPerfCapture(OwaUserConfigurationLogType.GetMaxRecipientsPerMessage, countersCapture, false);
owaUserConfiguration.RecoverDeletedItemsEnabled = configurationContext.RecoverDeletedItemsEnabled;
base.CallContext.ProtocolLog.Set(OwaUserConfigurationLogMetadata.UserCulture, owaUserConfiguration.SessionSettings.UserCulture);
Converter <KeyValuePair <string, string>, string> converter;
if (userContext.FeaturesManager.ServerSettings.FlightFormat.Enabled)
{
converter = ((KeyValuePair <string, string> pair) => "&" + pair.Key + ":" + pair.Value);
}
else
{
converter = ((KeyValuePair <string, string> pair) => pair.Key + " = " + pair.Value);
}
if (userContext.FeaturesManager.ConfigurationSnapshot != null && userContext.FeaturesManager.ClientSettings.OWADiagnostics.Enabled)
{
owaUserConfiguration.FlightConfiguration = Array.ConvertAll <KeyValuePair <string, string>, string>(userContext.FeaturesManager.ConfigurationSnapshot.Constraints, converter);
}
else
{
owaUserConfiguration.FlightConfiguration = new string[0];
}
this.ReadInferenceSettings(mailboxIdentityMailboxSession, userContext, owaUserConfiguration);
if (base.CallContext.IsSmimeInstalled)
{
owaUserConfiguration.SmimeAdminSettings = new SmimeAdminSettingsType(this.ReadAggregatedSmimeData(aggregationContext, organizationId));
}
VariantConfigurationSnapshot configurationSnapshot = userContext.FeaturesManager.ConfigurationSnapshot;
if (configurationSnapshot != null)
{
IInlineExploreSettings inlineExploreSettings = configurationSnapshot.OwaServer.InlineExploreSettings;
if (inlineExploreSettings != null)
{
owaUserConfiguration.InlineExploreContent = inlineExploreSettings.Content;
}
}
owaUserConfiguration.PolicyTipsEnabled = this.ReadAggregatedPolicyTipsData(aggregationContext, organizationId).IsPolicyTipsEnabled;
UserContext.ReadAggregatedFlightConfigData(aggregationContext, organizationId);
this.RecordAggregationStats(aggregationContext);
result = owaUserConfiguration;
}
finally
{
this.ValidateAndDisposeAggregatedConfiguration(aggregationContext, mailboxIdentityMailboxSession);
}
return(result);
}
internal static OwaFlightConfigData ReadAggregatedFlightConfigData(UserConfigurationManager.IAggregationContext aggregator, OrganizationId orgId)
{
return(UserContextUtilities.ReadAggregatedType <OwaFlightConfigData>(aggregator, "OWA.FlightConfiguration", () => UserContext.ReadFlightConfigDataFromAD(orgId)));
}
private OwaOrgConfigData ReadAggregatedOrgConfigData(UserConfigurationManager.IAggregationContext ctx, OrganizationId organizationId)
{
return(UserContextUtilities.ReadAggregatedType <OwaOrgConfigData>(ctx, "OWA.OrgConfig", () => UserContextUtilities.GetOrgConfigTypeFromAd(organizationId)));
}
// Token: 0x060007D8 RID: 2008 RVA: 0x00019FA8 File Offset: 0x000181A8
internal static T ReadAggregatedType <T>(UserConfigurationManager.IAggregationContext ctx, string key, Func <T> factory) where T : SerializableDataBase
{
return((ctx != null) ? ctx.ReadType <T>(key, factory) : factory());
}
