// Token: 0x0600160C RID: 5644 RVA: 0x00050308 File Offset: 0x0004E508
public static bool IsDownLevelClient(HttpContext httpContext, bool avoidUserContextAccess = false)
{
if (httpContext == null)
{
throw new ArgumentNullException("httpContext cannot be null");
}
HttpCookie httpCookie = httpContext.Request.Cookies["PALEnabled"];
if (httpCookie != null && !string.IsNullOrEmpty(httpCookie.Value))
{
return(false);
}
if (httpContext.Items.Contains("IsDownLevelClient"))
{
return((bool)httpContext.Items["IsDownLevelClient"]);
}
if (Utility.IsResourceRequest(httpContext.Request.Url.LocalPath))
{
avoidUserContextAccess = true;
}
bool flag = false;
bool flag2 = false;
bool flag3 = true;
bool isAndroidPremiumEnabled = false;
if (httpContext.User != null && httpContext.User.Identity.IsAuthenticated && !avoidUserContextAccess)
{
UserContext userContext = UserContextManager.GetMailboxContext(httpContext, null, true) as UserContext;
if (userContext != null)
{
bool flag4 = Culture.GetPreferredCultureInfo(userContext.ExchangePrincipal) != null;
if (flag4)
{
ConfigurationContext configurationContext = new ConfigurationContext(userContext);
flag3 = configurationContext.IsFeatureEnabled(Feature.RichClient);
flag2 = userContext.IsOptimizedForAccessibility;
flag = true;
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, string.Format("isOptimizedForAccessibility: {0}, isRichClientFeatureEnabled: {1}", flag2, flag3));
}
if (userContext.FeaturesManager.ServerSettings.AndroidPremium.Enabled)
{
isAndroidPremiumEnabled = true;
}
}
else
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "userContext is null when process IsDownLevelClient");
}
}
bool flag5 = RequestDispatcherUtilities.IsDownLevelClient(httpContext.Request, flag2, flag3, isAndroidPremiumEnabled);
if (flag)
{
httpContext.Items["IsDownLevelClient"] = flag5;
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, string.Format("Cache result '{0}' for IsDownLevelClient", flag5));
}
else
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, string.Format("Result '{0}' for IsDownLevelClient is not cached.", flag5));
}
return(flag5);
}
// Token: 0x06001619 RID: 5657 RVA: 0x00050A1C File Offset: 0x0004EC1C
internal static void SetXFrameOptionsHeader(RequestContext requestContext, OwaRequestType requestType)
{
if (requestContext == null)
{
return;
}
HttpContext httpContext = requestContext.HttpContext;
if (httpContext == null || !httpContext.Request.HttpMethod.Equals("GET") || (httpContext.Request.UserAgent != null && httpContext.Request.UserAgent.Contains("MSAppHost")))
{
return;
}
switch (requestType)
{
case OwaRequestType.EsoRequest:
case OwaRequestType.Oeh:
case OwaRequestType.ProxyPing:
case OwaRequestType.KeepAlive:
case OwaRequestType.Resource:
case OwaRequestType.PublishedCalendarView:
case OwaRequestType.ICalHttpHandler:
case OwaRequestType.HealthPing:
case OwaRequestType.SpeechReco:
break;
case OwaRequestType.Form15:
case OwaRequestType.ProxyLogon:
case OwaRequestType.LanguagePage:
case OwaRequestType.LanguagePost:
case OwaRequestType.Attachment:
case OwaRequestType.WebPart:
case OwaRequestType.ServiceRequest:
goto IL_9D;
default:
if (requestType != OwaRequestType.SuiteServiceProxyPage)
{
goto IL_9D;
}
break;
}
return;
IL_9D:
string value = "SAMEORIGIN";
if (RequestDispatcherUtilities.IsCmdWebPart(httpContext.Request))
{
UserContext userContext = (requestContext.UserContext ?? UserContextManager.GetMailboxContext(httpContext, null, true)) as UserContext;
if (userContext != null)
{
ConfigurationContext configurationContext = new ConfigurationContext(userContext);
if (configurationContext != null)
{
switch ((int)configurationContext.GetFeaturesEnabled(Feature.WebPartsDefaultOrigin | Feature.WebPartsEnableOrigins))
{
case 0:
case 1:
value = "DENY";
break;
case 2:
value = null;
break;
}
}
}
}
if (!string.IsNullOrEmpty(value))
{
httpContext.Response.Headers.Set("X-Frame-Options", value);
}
}
// Token: 0x06002177 RID: 8567 RVA: 0x0007A179 File Offset: 0x00078379
internal SegmentationSettingsType(ConfigurationContext configurationContext)
{
this.configurationContext = configurationContext;
this.segmentationFlags = this.configurationContext.SegmentationFlags;
}
protected override Stream InternalExecute()
{
UserContext userContext = UserContextManager.GetUserContext(HttpContext.Current, CallContext.Current.EffectiveCaller, true);
ConfigurationContext configurationContext = new ConfigurationContext(userContext);
string mailboxSmtpAddress = userContext.MailboxIdentity.PrimarySmtpAddress.ToString();
CobaltStoreSaver cobaltStoreSaver;
if (WacUtilities.ShouldUpdateAttachment(mailboxSmtpAddress, this.id, out cobaltStoreSaver))
{
base.CallContext.ProtocolLog.Set(GetAttachmentMetadata.Updated, true);
cobaltStoreSaver.SaveAndLogExceptions(base.CallContext.ProtocolLog);
}
else
{
base.CallContext.ProtocolLog.Set(GetAttachmentMetadata.Updated, false);
}
AttachmentHandler attachmentHandler = new AttachmentHandler(this.id, this.webOperationContext, base.CallContext, configurationContext);
attachmentHandler.IsImagePreview = this.isImagePreview;
Stream result;
try
{
using (AttachmentHandler.IAttachmentRetriever attachmentRetriever = AttachmentRetriever.CreateInstance(this.id, base.CallContext))
{
AttachmentHandler.IAttachmentPolicyChecker policyChecker = AttachmentPolicyChecker.CreateInstance(configurationContext.AttachmentPolicy);
Stream attachmentStream = attachmentHandler.GetAttachmentStream(attachmentRetriever, policyChecker, this.asDataUri);
GetAttachment.EliminateGzFileDoubleCompression(attachmentRetriever);
base.CallContext.OnDisposed += delegate(object sender, EventArgs args)
{
if (attachmentStream != null)
{
attachmentStream.Dispose();
}
};
if (attachmentRetriever.Attachment != null)
{
base.CallContext.ProtocolLog.Set(GetAttachmentMetadata.Extension, attachmentRetriever.Attachment.FileExtension);
base.CallContext.ProtocolLog.Set(GetAttachmentMetadata.Length, attachmentRetriever.Attachment.Size);
}
result = attachmentStream;
}
}
catch (InvalidStoreIdException innerException)
{
throw new OwaInvalidRequestException("Invalid ID, " + this.GetParametersForLogging(), innerException);
}
catch (InvalidIdMalformedException innerException2)
{
throw new OwaInvalidRequestException("Malformed ID, " + this.GetParametersForLogging(), innerException2);
}
catch (CannotOpenFileAttachmentException)
{
this.webOperationContext.StatusCode = HttpStatusCode.NotFound;
result = null;
}
catch (ObjectNotFoundException)
{
this.webOperationContext.StatusCode = HttpStatusCode.NotFound;
result = null;
}
return(result);
}
public static WacAttachmentType Execute(CallContext callContext, IStoreSession originalAttachmentSession, IItem originalAttachmentItem, IAttachment originalAttachment, string draftId, string ewsAttachmentId, bool isEdit)
{
MdbCache.GetInstance().BeginAsyncUpdate();
UserContext userContext = UserContextManager.GetUserContext(callContext.HttpContext, callContext.EffectiveCaller, true);
if (userContext == null)
{
throw new OwaInvalidRequestException("Unable to determine user context.");
}
if (!userContext.IsWacEditingEnabled)
{
isEdit = false;
}
ConfigurationContext configurationContext = new ConfigurationContext(userContext);
AttachmentPolicy attachmentPolicy = configurationContext.AttachmentPolicy;
bool isPublicLogon = userContext.IsPublicLogon;
if (!attachmentPolicy.GetWacViewingEnabled(isPublicLogon))
{
throw new OwaOperationNotSupportedException("WAC viewing not enabled for the current user");
}
MailboxSession mailboxSession = null;
StoreObjectId draftObjectId = null;
if (draftId != null)
{
IdAndSession idAndSession = GetWacAttachmentInfo.GetIdAndSession(callContext, draftId, false);
mailboxSession = (idAndSession.Session as MailboxSession);
draftObjectId = StoreId.EwsIdToStoreObjectId(draftId);
if (mailboxSession == null)
{
throw new OwaOperationNotSupportedException("We need a MailboxSession to create the draft, but this a " + idAndSession.Session.GetType().Name);
}
}
string text = originalAttachmentSession.MailboxOwner.MailboxInfo.PrimarySmtpAddress.ToString();
string primarySmtpAddress = callContext.EffectiveCaller.PrimarySmtpAddress;
RequestDetailsLogger protocolLog = callContext.ProtocolLog;
protocolLog.Set(GetWacAttachmentInfoMetadata.LogonSmtpAddress, primarySmtpAddress);
protocolLog.Set(GetWacAttachmentInfoMetadata.MailboxSmtpAddress, text);
protocolLog.Set(GetWacAttachmentInfoMetadata.Edit, isEdit);
protocolLog.Set(GetWacAttachmentInfoMetadata.Extension, originalAttachment.FileExtension);
protocolLog.Set(GetWacAttachmentInfoMetadata.DraftProvided, draftId != null);
string displayName = callContext.AccessingPrincipal.MailboxInfo.DisplayName;
XSOFactory factory = new XSOFactory();
AttachmentDataProvider defaultUploadDataProvider = new AttachmentDataProviderManager().GetDefaultUploadDataProvider(callContext);
IReferenceAttachment referenceAttachment = originalAttachment as IReferenceAttachment;
if (referenceAttachment != null)
{
GetWacAttachmentInfo.LogReferenceAttachmentProperties(protocolLog, referenceAttachment.ProviderEndpointUrl, GetWacAttachmentInfoMetadata.OriginalReferenceAttachmentServiceUrl, referenceAttachment.AttachLongPathName, GetWacAttachmentInfoMetadata.OriginalReferenceAttachmentUrl);
}
if (defaultUploadDataProvider != null)
{
protocolLog.Set(GetWacAttachmentInfoMetadata.AttachmentDataProvider, defaultUploadDataProvider.ToString());
}
WacAttachmentType wacAttachmentType;
try
{
using (GetWacAttachmentInfo.Implementation implementation = new GetWacAttachmentInfo.Implementation(defaultUploadDataProvider, factory, originalAttachmentSession, originalAttachmentSession.MailboxOwner.ModernGroupType, originalAttachmentItem, originalAttachment, ewsAttachmentId, mailboxSession, draftObjectId, isEdit, displayName, (IStoreSession session, StoreId itemId, AttachmentId attachmentId) => new IdAndSession(itemId, (StoreSession)session)
{
AttachmentIds =
{
attachmentId
}
}.GetConcatenatedId().Id))
{
implementation.Execute();
protocolLog.Set(GetWacAttachmentInfoMetadata.OriginalAttachmentType, implementation.OriginalAttachmentType);
protocolLog.Set(GetWacAttachmentInfoMetadata.ResultAttachmentType, implementation.ResultAttachmentType);
protocolLog.Set(GetWacAttachmentInfoMetadata.ResultAttachmentCreation, implementation.ResultAttachmentCreation);
if (implementation.ResultAttachmentType == AttachmentType.Reference)
{
IMailboxInfo mailboxInfo = originalAttachmentSession.MailboxOwner.MailboxInfo;
string mailboxAddress = mailboxInfo.PrimarySmtpAddress.ToString();
StoreId id = originalAttachmentItem.Id;
BaseItemId itemIdFromStoreId = IdConverter.GetItemIdFromStoreId(id, new MailboxId(mailboxInfo.MailboxGuid));
string exchangeSessionId = WacUtilities.GetExchangeSessionId(default(Guid).ToString());
protocolLog.Set(GetWacAttachmentInfoMetadata.ExchangeSessionId, exchangeSessionId);
wacAttachmentType = GetWacAttachmentInfo.GetResultForReferenceAttachment(callContext, userContext, implementation, defaultUploadDataProvider, mailboxAddress, itemIdFromStoreId, originalAttachment.FileName, isEdit, displayName, exchangeSessionId, protocolLog);
}
else
{
if (implementation.ResultAttachmentType != AttachmentType.Stream)
{
throw new OwaNotSupportedException("Unsupported attachment type " + implementation.ResultAttachmentType);
}
AttachmentIdType ewsAttachmentIdType = GetWacAttachmentInfo.GetEwsAttachmentIdType(callContext, implementation.ResultItemId, implementation.ResultAttachmentId);
wacAttachmentType = GetWacAttachmentInfo.GetResultForStreamAttachment(callContext, userContext, configurationContext, attachmentPolicy, isPublicLogon, Thread.CurrentThread.CurrentCulture.Name, isEdit, (IStreamAttachment)implementation.ResultAttachment, implementation.ResultAttachmentExtension, ewsAttachmentIdType, implementation.ResultIsInDraft, implementation.ResultStoreSession, text, originalAttachmentSession.MailboxOwner.MailboxInfo.IsArchive);
}
}
}
catch (ServerException exception)
{
wacAttachmentType = GetWacAttachmentInfo.HandleException(protocolLog, isEdit, exception, WacAttachmentStatus.UploadFailed);
}
catch (GetWacAttachmentInfo.AttachmentUploadException exception2)
{
wacAttachmentType = GetWacAttachmentInfo.HandleException(protocolLog, isEdit, exception2, WacAttachmentStatus.UploadFailed);
}
catch (RightsManagementPermanentException exception3)
{
wacAttachmentType = GetWacAttachmentInfo.HandleException(protocolLog, isEdit, exception3, WacAttachmentStatus.ProtectedByUnsupportedIrm);
}
catch (AttachmentProtectionException exception4)
{
wacAttachmentType = GetWacAttachmentInfo.HandleException(protocolLog, isEdit, exception4, WacAttachmentStatus.ProtectedByUnsupportedIrm);
}
catch (ObjectNotFoundException exception5)
{
wacAttachmentType = GetWacAttachmentInfo.HandleException(protocolLog, isEdit, exception5, WacAttachmentStatus.NotFound);
}
catch (OwaInvalidRequestException exception6)
{
wacAttachmentType = GetWacAttachmentInfo.HandleException(protocolLog, isEdit, exception6, WacAttachmentStatus.InvalidRequest);
}
catch (WacDiscoveryFailureException exception7)
{
wacAttachmentType = GetWacAttachmentInfo.HandleException(protocolLog, isEdit, exception7, WacAttachmentStatus.WacDiscoveryFailed);
}
catch (WebException exception8)
{
wacAttachmentType = GetWacAttachmentInfo.HandleException(protocolLog, isEdit, exception8, WacAttachmentStatus.AttachmentDataProviderError);
}
if (wacAttachmentType == null)
{
throw new OwaInvalidOperationException("There is no reason known for code to reach here without throwing an unhandled exception elsewhere");
}
protocolLog.Set(GetWacAttachmentInfoMetadata.Status, wacAttachmentType.Status.ToString());
return(wacAttachmentType);
}
private static WacAttachmentType GetResultForStreamAttachment(CallContext callContext, UserContext userContext, ConfigurationContext configurationContext, AttachmentPolicy attachmentPolicy, bool isPublicLogon, string cultureName, bool isEdit, IStreamAttachment attachment, string attachmentExtension, AttachmentIdType attachmentIdType, bool isInDraft, IStoreSession storeSession, string mailboxSmtpAddress, bool isArchive)
{
WacFileRep wacFileRep = GetWacAttachmentInfo.CreateWacFileRep(callContext, configurationContext, attachmentPolicy, isPublicLogon, isEdit, isArchive);
HttpRequest request = callContext.HttpContext.Request;
string text;
string arg;
GetWacAttachmentInfo.GenerateWopiSrcUrl(request, wacFileRep, mailboxSmtpAddress, out text, out arg);
if (text == null)
{
throw new OwaInvalidOperationException("WOPI URL is null.");
}
string id = attachmentIdType.Id;
TokenResult oauthToken = GetWacAttachmentInfo.GetOAuthToken(id, userContext, mailboxSmtpAddress, text);
string exchangeSessionId = WacUtilities.GetExchangeSessionId(oauthToken.TokenString);
callContext.ProtocolLog.Set(GetWacAttachmentInfoMetadata.ExchangeSessionId, exchangeSessionId);
SecurityIdentifier effectiveCallerSid = callContext.EffectiveCallerSid;
CachedAttachmentInfo.GetInstance(mailboxSmtpAddress, id, exchangeSessionId, effectiveCallerSid, cultureName);
string wacUrl = GetWacAttachmentInfo.GetWacUrl(isEdit, cultureName, attachmentExtension);
if (string.IsNullOrEmpty(wacUrl))
{
throw new OwaInvalidRequestException(string.Format("Wac Base Url is null for this given extension {0} and culture {1}", attachmentExtension, cultureName));
}
new Uri(wacUrl);
string format = "{0}WOPISrc={1}&access_token={2}";
string arg2 = HttpUtility.UrlEncode(oauthToken.TokenString);
string text2 = string.Format(format, wacUrl, HttpUtility.UrlEncode(text), arg2);
string value = string.Format(format, wacUrl, arg, arg2);
callContext.ProtocolLog.Set(GetWacAttachmentInfoMetadata.WacUrl, value);
if (!Uri.IsWellFormedUriString(text2, UriKind.Absolute))
{
throw new OwaInvalidOperationException("The WAC Iframe URL that was generated is not a well formed URI: " + text2);
}
return(new WacAttachmentType
{
AttachmentId = attachmentIdType,
IsEdit = isEdit,
IsInDraft = isInDraft,
WacUrl = text2,
Status = WacAttachmentStatus.Success
});
}
// Token: 0x06001A7B RID: 6779 RVA: 0x0006247C File Offset: 0x0006067C
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);
}