private static bool RedirectBecauseClientForgotTrailingSlashOnRoot(HttpApplication httpApplication, HttpContext httpContext, Uri originalUri)
{
bool result = false;
HttpRequest request = httpContext.Request;
if (request.HttpMethod == "GET")
{
string absolutePath = originalUri.AbsolutePath;
string rootWithSlash = RequestDispatcher.GetRootWithSlash();
string value = rootWithSlash.TrimEnd(new char[]
{
'/'
});
if (absolutePath.Equals(value, StringComparison.OrdinalIgnoreCase))
{
if (string.IsNullOrEmpty(originalUri.Query) && OfflineClientRequestUtilities.IsRequestForAppCachedVersion(httpContext))
{
RequestDispatcher.SendJavascriptRedirectTo(httpApplication, httpContext.Response, rootWithSlash);
result = true;
}
else
{
RequestDispatcher.Send301RedirectTo(httpContext.Response, rootWithSlash + originalUri.Query);
result = true;
}
}
}
return(result);
}
private static DispatchStepResult SendAppCacheRedirect(RequestContext requestContext, Uri originalUri)
{
HttpContext httpContext = requestContext.HttpContext;
HttpApplication applicationInstance = httpContext.ApplicationInstance;
string explicitLogonUser = UserContextUtilities.GetExplicitLogonUser(httpContext);
if (string.IsNullOrEmpty(explicitLogonUser))
{
RequestDispatcher.BindDefaultForceAppcacheCookieToSession(applicationInstance, httpContext);
if (RequestDispatcher.RedirectBecauseClientForgotTrailingSlashOnRoot(applicationInstance, httpContext, originalUri))
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::SendAppCacheRedirect] OwaModule redirected because client forgot the trailing slash on the root and that's in the appcache.");
return(DispatchStepResult.Stop);
}
if (RequestDispatcher.RedirectBecauseClientRequestedOwaRootSlashRealm(applicationInstance, httpContext, originalUri))
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::SendAppCacheRedirect] OwaModule redirected because the client requested /realm and that's in the appcache.");
return(DispatchStepResult.Stop);
}
if (RequestDispatcher.RedirectBecauseClientRequestedWebsiteRoot(applicationInstance, httpContext, originalUri))
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::SendAppCacheRedirect] OwaModule redirected because the client requested the website root and that's in the appcache.");
return(DispatchStepResult.Stop);
}
if (RequestDispatcher.RedirectBecauseIE10RequiresReloadFromAppcache(applicationInstance, httpContext, originalUri))
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::SendAppCacheRedirect] OwaModule told IE10 to reload so it can use the appcache.");
return(DispatchStepResult.Stop);
}
}
return(DispatchStepResult.Continue);
}
private static void BindDefaultForceAppcacheCookieToSession(HttpApplication httpApplication, HttpContext httpContext)
{
string a;
string text;
RequestDispatcher.GetIE10ForceAppcacheCookies(httpContext, out a, out text);
if (a == "1" && !string.IsNullOrEmpty(text))
{
RequestDispatcher.AddAlreadyForcedCookie(httpContext, text);
}
}
public static void DispatchRequest(RequestContext requestContext)
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::DispatchRequest] entry.");
HttpContext httpContext = requestContext.HttpContext;
UrlUtilities.RewriteFederatedDomainInURL(httpContext);
DispatchStepResult arg = RequestDispatcher.InternalDispatchRequest(requestContext);
ExTraceGlobals.CoreCallTracer.TraceDebug <DispatchStepResult>(0L, "[RequestDispatcher::DispatchRequest] Last dispatch step result={0}.", arg);
switch (arg)
{
case DispatchStepResult.RedirectToUrl:
ExTraceGlobals.CoreCallTracer.TraceDebug <string>(0L, "[RequestDispatcher::DispatchRequest] Redirecting response to '{0}'.", requestContext.DestinationUrl);
httpContext.Response.Redirect(requestContext.DestinationUrl, false);
if (requestContext.RequestType != OwaRequestType.Logoff || !RequestDispatcherUtilities.IsDownLevelClient(requestContext.HttpContext, false))
{
httpContext.ApplicationInstance.CompleteRequest();
}
return;
case DispatchStepResult.RewritePath:
ExTraceGlobals.CoreCallTracer.TraceDebug <string>(0L, "[RequestDispatcher::DispatchRequest] Rewriting path to '{0}'.", requestContext.DestinationUrl);
if (string.IsNullOrEmpty(requestContext.DestinationUrlQueryString))
{
httpContext.RewritePath(requestContext.DestinationUrl);
return;
}
httpContext.RewritePath(requestContext.DestinationUrl, null, requestContext.DestinationUrlQueryString);
break;
case DispatchStepResult.RewritePathToError:
case DispatchStepResult.Continue:
break;
case DispatchStepResult.EndResponse:
ExTraceGlobals.CoreCallTracer.TraceDebug <int>(0L, "[RequestDispatcher::DispatchRequest] Ending response with statusCode={0}.", (int)requestContext.HttpStatusCode);
HttpUtilities.EndResponse(requestContext.HttpContext, requestContext.HttpStatusCode);
return;
case DispatchStepResult.EndResponseWithPrivateCaching:
ExTraceGlobals.CoreCallTracer.TraceDebug <int>(0L, "[RequestDispatcher::DispatchRequest] Ending response with statusCode={0} and PRIVATE cacheability.", (int)requestContext.HttpStatusCode);
HttpUtilities.EndResponse(requestContext.HttpContext, requestContext.HttpStatusCode, HttpCacheability.Private);
return;
case DispatchStepResult.Stop:
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::DispatchRequest] Stopped the dispatching of this request.");
return;
default:
return;
}
}
private static bool ForceIE10ReloadToUseAppcacheIfNotAlreadyDone(HttpApplication httpApplication, HttpContext httpContext)
{
bool result = false;
string text;
string text2;
RequestDispatcher.GetIE10ForceAppcacheCookies(httpContext, out text, out text2);
if (text != "1" && (string.IsNullOrEmpty(text) || text2 != text))
{
string cookieValue = string.IsNullOrEmpty(text2) ? "1" : text2;
RequestDispatcher.AddAlreadyForcedCookie(httpContext, cookieValue);
RequestDispatcher.SendJavascriptReload(httpApplication, httpContext);
result = true;
}
return(result);
}
private static bool RedirectBecauseIE10RequiresReloadFromAppcache(HttpApplication httpApplication, HttpContext httpContext, Uri originalUri)
{
bool result = false;
HttpRequest request = httpContext.Request;
if (request.HttpMethod == "GET")
{
string absolutePath = originalUri.AbsolutePath;
string rootWithSlash = RequestDispatcher.GetRootWithSlash();
if (absolutePath.Equals(rootWithSlash, StringComparison.OrdinalIgnoreCase) && RequestDispatcher.IsBrowserIE10(httpContext) && !OfflineClientRequestUtilities.IsRequestForAppCachedVersion(httpContext) && !DefaultPageBase.IsPalEnabled(httpContext))
{
result = RequestDispatcher.ForceIE10ReloadToUseAppcacheIfNotAlreadyDone(httpApplication, httpContext);
}
}
return(result);
}
private static bool RedirectBecauseClientRequestedWebsiteRoot(HttpApplication httpApplication, HttpContext httpContext, Uri originalUri)
{
bool result = false;
HttpRequest request = httpContext.Request;
if (request.HttpMethod == "GET")
{
string absolutePath = originalUri.AbsolutePath;
string rootWithSlash = RequestDispatcher.GetRootWithSlash();
if (string.IsNullOrEmpty(absolutePath) || absolutePath.Equals("/", StringComparison.OrdinalIgnoreCase))
{
RequestDispatcher.SendJavascriptRedirectTo(httpApplication, httpContext.Response, rootWithSlash + originalUri.Query);
result = true;
}
}
return(result);
}
private static DispatchStepResult DispatchIfLanguagePost(RequestContext requestContext)
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::DispatchIfLanguagePost] entry.");
Canary15Cookie.CanaryValidationResult canaryValidationResult;
if (requestContext.RequestType == OwaRequestType.LanguagePost && HttpUtilities.IsPostRequest(requestContext.HttpContext.Request) && Canary15Cookie.ValidateCanaryInHeaders(requestContext.HttpContext, OwaRequestHandler.GetOriginalIdentitySid(requestContext.HttpContext), Canary15Profile.Owa, out canaryValidationResult))
{
OwaDiagnostics.TracePfd(25865, "The request is a post from the language selection page, processing this request...", new object[0]);
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::DispatchIfLanguagePost] Dispatching.");
HttpRequest request = requestContext.HttpContext.Request;
CultureInfo culture;
string timeZoneKeyName;
bool isOptimized;
string destination;
RequestDispatcherUtilities.GetLanguagePostFormParameters(requestContext, request, out culture, out timeZoneKeyName, out isOptimized, out destination);
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::DispatchIfLanguagePost] Dispatching language post request locally...");
return(RequestDispatcher.HandleLanguagePost(requestContext, culture, timeZoneKeyName, isOptimized, destination));
}
return(DispatchStepResult.Continue);
}
private static DispatchStepResult DispatchIfLogoffRequest(RequestContext requestContext)
{
if (requestContext.RequestType != OwaRequestType.Logoff)
{
return(DispatchStepResult.Continue);
}
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::DispatchIfLogoffRequest] entry.");
OwaDiagnostics.TracePfd(21769, "Dispatching logoff request.", new object[0]);
requestContext.UserContext = UserContextManager.GetUserContext(requestContext.HttpContext, false);
if (requestContext.UserContext != null)
{
RequestDispatcher.DoLogoffCleanup(requestContext);
}
if (RequestDispatcherUtilities.IsChangePasswordLogoff(requestContext.HttpContext.Request))
{
requestContext.DestinationUrl = OwaUrl.LogoffChangePasswordPage.GetExplicitUrl(requestContext.HttpContext.Request);
}
else
{
requestContext.DestinationUrl = RequestDispatcher.GetLogoffURL(requestContext);
}
return(DispatchStepResult.RedirectToUrl);
}
private static bool RedirectBecauseClientRequestedOwaRootSlashRealm(HttpApplication httpApplication, HttpContext httpContext, Uri originalUri)
{
bool result = false;
HttpRequest request = httpContext.Request;
if (request.HttpMethod == "GET")
{
string rootWithSlash = RequestDispatcher.GetRootWithSlash();
string absolutePath = originalUri.AbsolutePath;
string text = httpContext.Request.QueryString["realm"] ?? string.Empty;
if (!string.IsNullOrEmpty(text))
{
string text2 = Uri.EscapeDataString(text.ToLowerInvariant());
if (absolutePath.Equals(rootWithSlash + text2, StringComparison.OrdinalIgnoreCase) || absolutePath.Equals(rootWithSlash + text2 + "/", StringComparison.OrdinalIgnoreCase))
{
string str = string.IsNullOrEmpty(originalUri.Query) ? "?" : (originalUri.Query + "&");
string str2 = string.Format("{0}={1}", "realm", text2);
RequestDispatcher.SendJavascriptRedirectTo(httpApplication, httpContext.Response, rootWithSlash + str + str2);
result = true;
}
}
}
return(result);
}
private static void InternalOnPostAuthorizeRequest(object sender)
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[OwaRequestHandler::InternalOnPostAuthorizeRequest] entry.");
RequestDetailsLogger getRequestDetailsLogger = OwaApplication.GetRequestDetailsLogger;
SubActivityScopeLogger subActivityScopeLogger = SubActivityScopeLogger.Create(getRequestDetailsLogger, OwaServerLogger.LoggerData.OnPostAuthorizeRequestLatencyDetails);
HttpApplication httpApplication = (HttpApplication)sender;
HttpContext context = httpApplication.Context;
if (!context.Request.IsAuthenticated && (context.Request.Url.LocalPath.EndsWith("service.svc", StringComparison.OrdinalIgnoreCase) || context.Request.Url.LocalPath.EndsWith("Speech.reco", StringComparison.OrdinalIgnoreCase)))
{
ExTraceGlobals.CoreCallTracer.TraceDebug <string>(0L, "[OwaRequestHandler::InternalOnPostAuthorizeRequest] unauthorized request. Request URL={0}.", context.Request.Url.OriginalString);
context.Response.StatusCode = 401;
httpApplication.CompleteRequest();
return;
}
RequestContext requestContext = RequestContext.Get(httpApplication.Context);
subActivityScopeLogger.LogNext("a");
RequestDispatcher.DispatchRequest(requestContext);
subActivityScopeLogger.LogNext("b");
OwaRequestType requestType = requestContext.RequestType;
RequestDispatcherUtilities.SetXFrameOptionsHeader(RequestContext.Current, requestType);
subActivityScopeLogger.LogNext("c");
if (context.User != null && context.User.Identity != null)
{
if (context.User.Identity is ClientSecurityContextIdentity)
{
IMailboxContext mailboxContext = UserContextManager.GetMailboxContext(context, null, false);
subActivityScopeLogger.LogNext("d");
if (OwaRequestHandler.IsProxyLogonRequest(requestType))
{
ExTraceGlobals.CoreCallTracer.TraceDebug <OwaRequestType>(0L, "[OwaRequestHandler::InternalOnPostAuthorizeRequest] proxy logon request. RequestType={0}", requestType);
return;
}
RequestDetailsLogger.LogEvent(getRequestDetailsLogger, OwaServerLogger.LoggerData.CanaryValidationBegin);
bool flag = OwaRequestHandler.IsRequestWithCanary(context.Request, requestType, context.Request.IsAuthenticated);
bool flag2 = OwaRequestHandler.IsAfterLogonRequest(context.Request);
string originalIdentitySid = OwaRequestHandler.GetOriginalIdentitySid(context);
CanaryLogEvent.CanaryStatus canaryStatus = CanaryLogEvent.CanaryStatus.None;
bool flag3 = !flag || flag2;
if (!flag3)
{
Canary15Cookie.CanaryValidationResult canaryValidationResult;
flag3 = Canary15Cookie.ValidateCanaryInHeaders(context, originalIdentitySid, Canary15Profile.Owa, out canaryValidationResult);
canaryStatus |= (CanaryLogEvent.CanaryStatus)canaryValidationResult;
}
OwaRequestHandler.UpdateCanaryStatus(ref canaryStatus, flag, CanaryLogEvent.CanaryStatus.IsCanaryNeeded);
OwaRequestHandler.UpdateCanaryStatus(ref canaryStatus, flag3, CanaryLogEvent.CanaryStatus.IsCanaryValid);
OwaRequestHandler.UpdateCanaryStatus(ref canaryStatus, flag2, CanaryLogEvent.CanaryStatus.IsCanaryAfterLogonRequest);
Canary15Cookie canary15Cookie = Canary15Cookie.TryCreateFromHttpContext(context, originalIdentitySid, Canary15Profile.Owa);
OwaRequestHandler.UpdateCanaryStatus(ref canaryStatus, canary15Cookie.IsAboutToExpire, CanaryLogEvent.CanaryStatus.IsCanaryAboutToExpire);
OwaRequestHandler.UpdateCanaryStatus(ref canaryStatus, canary15Cookie.IsRenewed, CanaryLogEvent.CanaryStatus.IsCanaryRenewed);
subActivityScopeLogger.LogNext("e");
bool flag4 = flag || canary15Cookie.IsAboutToExpire;
if (flag4)
{
canary15Cookie = new Canary15Cookie(originalIdentitySid, Canary15Profile.Owa);
}
if (canary15Cookie.IsRenewed || flag4)
{
context.Response.SetCookie(canary15Cookie.HttpCookie);
CanaryLogEvent logEvent = new CanaryLogEvent(context, mailboxContext, canaryStatus, canary15Cookie.CreationTime, canary15Cookie.LogData);
OwaServerLogger.AppendToLog(logEvent);
subActivityScopeLogger.LogNext("f");
}
if (flag3)
{
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(getRequestDetailsLogger, OwaServerLogger.LoggerData.CanaryCreationTime, canary15Cookie.CreationTime);
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(getRequestDetailsLogger, OwaServerLogger.LoggerData.CanaryLogData, canary15Cookie.LogData);
subActivityScopeLogger.LogNext("g");
}
else
{
if (RequestDispatcherUtilities.IsDownLevelClient(context, false))
{
throw new OwaCanaryException(Canary15Profile.Owa.Name, canary15Cookie.Value);
}
context.Response.StatusCode = 449;
context.Response.End();
}
RequestDetailsLoggerBase <RequestDetailsLogger> requestDetailsLogger = getRequestDetailsLogger;
Enum key = OwaServerLogger.LoggerData.CanaryStatus;
int num = (int)canaryStatus;
RequestDetailsLoggerBase <RequestDetailsLogger> .SafeSetLogger(requestDetailsLogger, key, num.ToString("X"));
RequestDetailsLogger.LogEvent(getRequestDetailsLogger, OwaServerLogger.LoggerData.CanaryValidationEnd);
subActivityScopeLogger.LogEnd();
return;
}
}
else
{
ExTraceGlobals.CoreCallTracer.TraceError(0L, "[OwaRequestHandler::InternalOnPostAuthorizeRequest] httpContext.User or httpContext.User.Identity is <NULL>.");
}
}
private static DispatchStepResult ValidateAndSetThreadCulture(RequestContext requestContext)
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::ValidateAndSetThreadCulture] entry.");
CultureInfo cultureInfo = null;
EcpUserSettings ecpUserSettings = (EcpUserSettings)0U;
UserContext userContext = requestContext.UserContext as UserContext;
if (requestContext.UserContext != null && userContext == null)
{
throw new OwaInvalidOperationException(string.Format("Context was expected to be of type UserContext, but it is of type {0}", requestContext.UserContext.GetType()));
}
if (RequestDispatcherUtilities.TryReadUpdatedUserSettingsCookie(requestContext, out ecpUserSettings))
{
cultureInfo = RequestDispatcherUtilities.GetUserCultureFromEcpCookie(requestContext, ecpUserSettings);
if (userContext != null)
{
userContext.RefreshUserSettings(cultureInfo, ecpUserSettings);
}
RequestDispatcherUtilities.DeleteUserSettingsCookie(requestContext);
}
if (cultureInfo == null)
{
bool flag = requestContext.RequestType == OwaRequestType.SuiteServiceProxyPage;
if (requestContext.LanguagePostUserCulture != null)
{
cultureInfo = requestContext.LanguagePostUserCulture;
}
else if (userContext != null && !flag)
{
cultureInfo = Culture.GetPreferredCultureInfo(userContext.ExchangePrincipal);
if (cultureInfo == null && userContext.IsExplicitLogon)
{
cultureInfo = ClientCultures.GetPreferredCultureInfo(userContext.LogonIdentity.GetOWAMiniRecipient().Languages);
userContext.UserCulture = cultureInfo;
}
if (cultureInfo == null)
{
if (string.IsNullOrEmpty(requestContext.DestinationUrlQueryString))
{
requestContext.DestinationUrlQueryString = requestContext.HttpContext.Request.QueryString.ToString();
}
bool flag2 = string.IsNullOrEmpty(requestContext.HttpContext.Request.Headers["X-SuiteServiceProxyOrigin"]);
CultureInfo culture;
string timeZoneKeyName;
if (OfflineClientRequestUtilities.IsRequestFromMOWAClient(requestContext.HttpContext.Request, requestContext.HttpContext.Request.UserAgent) && RequestDispatcherUtilities.TryReadMowaGlobalizationSettings(requestContext, out culture, out timeZoneKeyName))
{
return(RequestDispatcher.HandleLanguagePost(requestContext, culture, timeZoneKeyName, false, requestContext.DestinationUrl));
}
if (flag2)
{
requestContext.DestinationUrl = RequestDispatcherUtilities.GetDestinationForRedirectToLanguagePage(requestContext);
requestContext.HttpContext.Response.AppendHeader("X-OWA-Version", Globals.ApplicationVersion);
requestContext.HttpContext.Response.AppendToLog("&redir=lang");
return(DispatchStepResult.RedirectToUrl);
}
requestContext.HttpContext.Response.Headers["X-OWA-Error"] = "OwaInvalidUserLanguageException";
requestContext.HttpStatusCode = HttpStatusCode.NoContent;
return(DispatchStepResult.EndResponse);
}
else if (userContext.IsUserCultureExplicitlySet)
{
cultureInfo = userContext.UserCulture;
}
}
}
if (cultureInfo != null)
{
Culture.InternalSetThreadPreferredCulture(cultureInfo);
}
else
{
Culture.InternalSetThreadPreferredCulture();
}
return(DispatchStepResult.Continue);
}
private static DispatchStepResult HandleLanguagePost(RequestContext requestContext, CultureInfo culture, string timeZoneKeyName, bool isOptimized, string destination)
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::HandleLanguagePost] entry.");
if (requestContext.UserContext == null)
{
throw new OwaInvalidOperationException("UserContext should be created by the time language post is handled");
}
requestContext.LanguagePostUserCulture = culture;
requestContext.HttpContext.Response.Cookies.Set(new HttpCookie("mkt", culture.Name));
if (!string.IsNullOrWhiteSpace(destination) && (destination.StartsWith("/ecp/", StringComparison.OrdinalIgnoreCase) || destination.StartsWith("/owa/", StringComparison.OrdinalIgnoreCase)))
{
requestContext.DestinationUrl = destination;
}
else
{
requestContext.DestinationUrl = string.Empty;
}
Culture.InternalSetThreadPreferredCulture(culture);
MailboxSession mailboxSession = null;
try
{
ExTraceGlobals.CoreCallTracer.TraceDebug <string, bool>(0L, "[RequestDispatcher::HandleLanguagePost] Attempting to save the timeZoneKeyName (tzid={0}) and isOptimized={1} in the mailbox.", timeZoneKeyName, isOptimized);
OwaIdentity logonIdentity = requestContext.UserContext.LogonIdentity;
mailboxSession = logonIdentity.CreateMailboxSession(requestContext.UserContext.ExchangePrincipal, culture);
if (requestContext.UserContext.IsExplicitLogon && !mailboxSession.CanActAsOwner)
{
throw new OwaExplicitLogonException("User has no access rights to the mailbox", "ErrorExplicitLogonAccessDenied");
}
try
{
ExTraceGlobals.CoreCallTracer.TraceDebug <int>(0L, "[RequestDispatcher::HandleLanguagePost] Trying to save the culture to the AD (lcid={0})", culture.LCID);
PreferredCultures preferredCultures = new PreferredCultures(requestContext.UserContext.ExchangePrincipal.PreferredCultures);
preferredCultures.AddSupportedCulture(culture, new Predicate <CultureInfo>(ClientCultures.IsSupportedCulture));
Culture.SetPreferredCulture(requestContext.UserContext.ExchangePrincipal, preferredCultures, mailboxSession.GetADRecipientSession(false, ConsistencyMode.FullyConsistent));
requestContext.UserContext.ExchangePrincipal = requestContext.UserContext.ExchangePrincipal.WithPreferredCultures(preferredCultures);
}
catch (Exception ex)
{
if (!(ex is ADOperationException) && !(ex is InvalidOperationException))
{
throw;
}
requestContext.FailedToSaveUserCulture = true;
if (ExTraceGlobals.CoreCallTracer.IsTraceEnabled(TraceType.ErrorTrace))
{
StringBuilder stringBuilder = new StringBuilder("Failed to save user's culture in the AD.");
stringBuilder.Append("\n\nException: ");
stringBuilder.Append(ex.GetType().ToString());
stringBuilder.Append("\n");
stringBuilder.Append(ex.Message);
stringBuilder.Append(")");
if (!string.IsNullOrEmpty(ex.StackTrace))
{
stringBuilder.Append("\n\nCallstack:\n");
stringBuilder.Append(ex.StackTrace);
}
ExTraceGlobals.CoreCallTracer.TraceError(0L, stringBuilder.ToString());
}
}
UserOptionsType userOptionsType = new UserOptionsType();
bool flag = true;
try
{
userOptionsType.Load(mailboxSession, false, false);
}
catch (QuotaExceededException ex2)
{
ExTraceGlobals.UserContextCallTracer.TraceDebug <string>(0L, "[RequestDispatcher::HandleLanguagePost] UserOptions.LoadAll failed. Exception: {0}.", ex2.Message);
flag = false;
}
userOptionsType.TimeZone = timeZoneKeyName;
userOptionsType.IsOptimizedForAccessibility = isOptimized;
userOptionsType.UserOptionsMigrationState = UserOptionsMigrationState.WorkingHoursTimeZoneFixUp;
if (flag)
{
UserConfigurationPropertyDefinition propertyDefinition = UserOptionPropertySchema.Instance.GetPropertyDefinition(UserConfigurationPropertyId.TimeZone);
UserConfigurationPropertyDefinition propertyDefinition2 = UserOptionPropertySchema.Instance.GetPropertyDefinition(UserConfigurationPropertyId.IsOptimizedForAccessibility);
UserConfigurationPropertyDefinition propertyDefinition3 = UserOptionPropertySchema.Instance.GetPropertyDefinition(UserConfigurationPropertyId.UserOptionsMigrationState);
userOptionsType.Commit(mailboxSession, new UserConfigurationPropertyDefinition[]
{
propertyDefinition,
propertyDefinition2,
propertyDefinition3
});
}
RequestDispatcher.InitializeFavorites(mailboxSession);
}
finally
{
if (mailboxSession != null)
{
UserContextUtilities.DisconnectStoreSession(mailboxSession);
mailboxSession.Dispose();
mailboxSession = null;
}
}
return(DispatchStepResult.Continue);
}
private static DispatchStepResult InternalDispatchRequest(RequestContext requestContext)
{
HttpRequest request = requestContext.HttpContext.Request;
requestContext.RequestType = RequestDispatcherUtilities.GetRequestType(request);
ExTraceGlobals.CoreCallTracer.TraceDebug <OwaRequestType>(0L, "[RequestDispatcher::InternalDispatchRequest] Processing requestType={0}.", requestContext.RequestType);
OwaRequestType requestType = requestContext.RequestType;
if (requestType <= OwaRequestType.LanguagePage)
{
switch (requestType)
{
case OwaRequestType.Invalid:
requestContext.HttpStatusCode = HttpStatusCode.BadRequest;
return(DispatchStepResult.EndResponse);
case OwaRequestType.Authorize:
break;
case OwaRequestType.Logoff:
case OwaRequestType.Aspx:
goto IL_C2;
case OwaRequestType.EsoRequest:
return(DispatchStepResult.Stop);
default:
switch (requestType)
{
case OwaRequestType.ProxyPing:
RequestDispatcherUtilities.RespondProxyPing(requestContext);
return(DispatchStepResult.EndResponse);
case OwaRequestType.LanguagePage:
break;
default:
goto IL_C2;
}
break;
}
requestContext.HttpContext.Response.AppendHeader("X-OWA-Version", Globals.ApplicationVersion);
return(DispatchStepResult.Stop);
}
if (requestType == OwaRequestType.Resource)
{
return(DispatchStepResult.Stop);
}
switch (requestType)
{
case OwaRequestType.WopiRequest:
return(DispatchStepResult.Stop);
case OwaRequestType.RemoteNotificationRequest:
return(DispatchStepResult.Stop);
case OwaRequestType.GroupSubscriptionRequest:
return(DispatchStepResult.Stop);
}
IL_C2:
if (!requestContext.HttpContext.Request.IsAuthenticated)
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::InternalDispatchRequest] Request not authenticated. returning.");
requestContext.HttpStatusCode = HttpStatusCode.Unauthorized;
return(DispatchStepResult.EndResponse);
}
DispatchStepResult dispatchStepResult = RequestDispatcher.DispatchIfLogoffRequest(requestContext);
if (dispatchStepResult != DispatchStepResult.Continue)
{
ExTraceGlobals.CoreCallTracer.TraceDebug <DispatchStepResult>(0L, "[RequestDispatcher::InternalDispatchRequest] DispatchIfLogoffRequest returned {0}. returning.", dispatchStepResult);
return(dispatchStepResult);
}
dispatchStepResult = RequestDispatcher.DispatchIfLastPendingGet(requestContext);
if (dispatchStepResult != DispatchStepResult.Continue)
{
ExTraceGlobals.CoreCallTracer.TraceDebug <DispatchStepResult>(0L, "[RequestDispatcher::InternalDispatchRequest] DispatchIfLastPendingGet returned {0}. returning.", dispatchStepResult);
return(dispatchStepResult);
}
dispatchStepResult = RequestDispatcher.DispatchIfGetUserPhotoRequest(requestContext);
if (dispatchStepResult != DispatchStepResult.Continue)
{
ExTraceGlobals.CoreCallTracer.TraceDebug <DispatchStepResult>(0L, "[RequestDispatcher::InternalDispatchRequest] DispatchIfGetUserPhotoRequest returned {0}. returning.", dispatchStepResult);
return(dispatchStepResult);
}
requestContext.UserContext = UserContextManager.GetMailboxContext(requestContext.HttpContext, null, true);
if (!requestContext.UserContext.ExchangePrincipal.MailboxInfo.Configuration.IsOwaEnabled && !OfflineClientRequestUtilities.IsRequestFromMOWAClient(requestContext.HttpContext.Request, requestContext.HttpContext.Request.UserAgent))
{
ExTraceGlobals.CoreCallTracer.TraceDebug(0L, "[RequestDispatcher::InternalDispatchRequest] OWA Disabled: redirecting to error page.");
throw new AccountDisabledException(new LocalizedString(Strings.GetLocalizedString(531497785)));
}
if (RequestDispatcher.ShouldBlockConnection(requestContext.HttpContext, requestContext.UserContext.LogonIdentity))
{
ExTraceGlobals.CoreCallTracer.TraceWarning <string>(0L, "[RequestDispatcher::InternalOnPostAuthorizeRequest] blocked by Client Access Rules. Request URL={0}.", requestContext.HttpContext.Request.Url.OriginalString);
if (requestContext.UserContext.LogonIdentity.UserOrganizationId != null && !OrganizationId.ForestWideOrgId.Equals(requestContext.UserContext.LogonIdentity.UserOrganizationId))
{
requestContext.DestinationUrl = OwaUrl.LogoffPageBlockedByClientAccessRules.GetExplicitUrl(requestContext.HttpContext.Request);
}
else
{
requestContext.DestinationUrl = OwaUrl.LogoffBlockedByClientAccessRules.GetExplicitUrl(requestContext.HttpContext.Request);
}
return(DispatchStepResult.RedirectToUrl);
}
dispatchStepResult = RequestDispatcher.ValidateExplicitLogonPermissions(requestContext);
if (dispatchStepResult != DispatchStepResult.Continue)
{
ExTraceGlobals.CoreCallTracer.TraceDebug <DispatchStepResult>(0L, "[RequestDispatcher::InternalDispatchRequest] ValidateExplicitLogonPermissions returned {0}. returning.", dispatchStepResult);
return(dispatchStepResult);
}
dispatchStepResult = RequestDispatcher.DispatchIfLanguagePost(requestContext);
if (dispatchStepResult != DispatchStepResult.Continue)
{
ExTraceGlobals.CoreCallTracer.TraceDebug <DispatchStepResult>(0L, "[RequestDispatcher::InternalDispatchRequest] DispatchIfLanguagePost returned {0}. returning.", dispatchStepResult);
return(dispatchStepResult);
}
if (requestContext.UserContext is UserContext)
{
dispatchStepResult = RequestDispatcher.ValidateAndSetThreadCulture(requestContext);
if (dispatchStepResult != DispatchStepResult.Continue)
{
ExTraceGlobals.CoreCallTracer.TraceDebug <DispatchStepResult>(0L, "[RequestDispatcher::InternalDispatchRequest] ValidateAndSetThreadCulture returned {0}. returning.", dispatchStepResult);
return(dispatchStepResult);
}
}
Uri originalRequestUrlFromContext = UrlUtilities.GetOriginalRequestUrlFromContext(requestContext.HttpContext);
dispatchStepResult = RequestDispatcher.SendAppCacheRedirect(requestContext, originalRequestUrlFromContext);
if (dispatchStepResult != DispatchStepResult.Continue)
{
ExTraceGlobals.CoreCallTracer.TraceDebug <DispatchStepResult>(0L, "[RequestDispatcher::InternalDispatchRequest] SendAppCacheRedirect returned {0}. returning.", dispatchStepResult);
return(dispatchStepResult);
}
requestContext.HttpContext.Response.AppendHeader("X-OWA-Version", Globals.ApplicationVersion);
requestContext.HttpContext.Response.AppendHeader("X-OWA-OWSVersion", ExchangeVersion.Latest.Version.ToString());
requestContext.HttpContext.Response.AppendHeader("X-OWA-MinimumSupportedOWSVersion", ExchangeVersionType.V2_6.ToString());
RequestDispatcher.SetTimeoutForRequest(requestContext.HttpContext, requestContext.RequestType);
RequestDispatcher.CheckAndAddHostNameChangedCookie(requestContext, request);
return(RequestDispatcher.DoFinalDispatch(requestContext));
}
