internal void DoPostResolveRequestCache(HttpContextBase context)
{
if (IsExplicitlyDisabled)
{
// If the root config is explicitly disabled, do not process the request.
return;
}
// Parse incoming URL (we trim off the first two chars since they're always "~/")
string requestPath = context.Request.AppRelativeCurrentExecutionFilePath.Substring(2) + context.Request.PathInfo;
string[] registeredExtensions = WebPageHttpHandler.SupportedExtensions;
// Check if this request matches a file in the app
WebPageMatch webpageRouteMatch = MatchRequest(requestPath, registeredExtensions, VirtualPathFactoryManager.InstancePathExists, context, DisplayModeProvider.Instance);
if (webpageRouteMatch != null)
{
// If it matches then save some data for the WebPage's UrlData
context.Items[typeof(WebPageMatch)] = webpageRouteMatch;
string virtualPath = "~/" + webpageRouteMatch.MatchedPath;
// Verify that this path is enabled before remapping
if (!WebPagesDeployment.IsExplicitlyDisabled(virtualPath))
{
IHttpHandler handler = WebPageHttpHandler.CreateFromVirtualPath(virtualPath);
if (handler != null)
{
SessionStateUtil.SetUpSessionState(context, handler);
// Remap to our handler
context.RemapHandler(handler);
}
}
}
else
{
// Bug:904704 If its not a match, but to a supported extension, we want to return a 404 instead of a 403
string extension = PathUtil.GetExtension(requestPath);
foreach (string supportedExt in registeredExtensions)
{
if (String.Equals("." + supportedExt, extension, StringComparison.OrdinalIgnoreCase))
{
throw new HttpException(404, null);
}
}
}
}
public override void ExecutePageHierarchy()
{
// Unlike InitPages, for a WebPage there is no hierarchy - it is always
// the last file to execute in the chain. There can still be layout pages
// and partial pages, but they are never part of the hierarchy.
// (add server header for falcon debugging)
// call to MapPath() is expensive. If we are not emiting source files to header,
// don't bother to populate the SourceFiles collection. This saves perf significantly.
if (WebPageHttpHandler.ShouldGenerateSourceHeader(Context))
{
try
{
string vp = VirtualPath;
if (vp != null)
{
string path = Context.Request.MapPath(vp);
if (!path.IsEmpty())
{
PageContext.SourceFiles.Add(path);
}
}
}
catch
{
// we really don't care if this ever fails, so we swallow all exceptions
}
}
TemplateStack.Push(Context, this);
try
{
// Execute the developer-written code of the WebPage
Execute();
}
finally
{
TemplateStack.Pop(Context);
}
}
internal static void SetUpSessionState(
HttpContextBase context,
IHttpHandler handler,
ConcurrentDictionary <Type, SessionStateBehavior?> cache
)
{
WebPageHttpHandler webPageHandler = handler as WebPageHttpHandler;
Debug.Assert(handler != null);
SessionStateBehavior?sessionState = GetSessionStateBehavior(
webPageHandler.RequestedPage,
cache
);
if (sessionState != null)
{
// If the page explicitly specifies a session state value, return since it has the most priority.
context.SetSessionStateBehavior(sessionState.Value);
return;
}
WebPageRenderingBase page = webPageHandler.StartPage;
StartPage startPage = null;
do
{
// Drill down _AppStart and _PageStart.
startPage = page as StartPage;
if (startPage != null)
{
sessionState = GetSessionStateBehavior(page, cache);
page = startPage.ChildPage;
}
} while (startPage != null);
if (sessionState != null)
{
context.SetSessionStateBehavior(sessionState.Value);
}
}
public static void Start()
{
// Even though ASP.NET will only call each PreAppStart once, we sometimes internally call one PreAppStart from
// another PreAppStart to ensure that things get initialized in the right order. ASP.NET does not guarantee the
// order so we have to guard against multiple calls.
// All Start calls are made on same thread, so no lock needed here.
if (_startWasCalled)
{
return;
}
_startWasCalled = true;
WebPageHttpHandler.RegisterExtension("cshtml");
// Turn off the string resource behavior which would not work in our simple base page
PageParser.EnableLongStringsAsResources = false;
DynamicModuleUtility.RegisterModule(typeof(WebPageHttpModule));
ScopeStorage.CurrentProvider = new AspNetRequestScopeStorageProvider();
}
internal void ProcessRequestInternal(HttpContext context)
{
// enable dynamic validation for this request
ValidationUtility.EnableDynamicValidation(context);
context.Request.ValidateInput();
try {
HttpContextBase contextBase = new HttpContextWrapper(context);
//WebSecurity.Context = contextBase;
AddVersionHeader(contextBase);
WebPageRenderingBase startPage = StartPage.GetStartPage(_webPage, StartPageFileName, WebPageHttpHandler.GetRegisteredExtensions());
// This is also the point where a Plan9 request truly begins execution
// We call ExecutePageHierarchy on the requested page, passing in the possible initPage, so that
// the requested page can take care of the necessary push/pop context and trigger the call to
// the initPage.
_webPage.ExecutePageHierarchy(Util.CreatePageContext(context), context.Response.Output, startPage);
if (ShouldGenerateSourceHeader(contextBase))
{
GenerateSourceFilesHeader(_webPage.PageContext);
}
}
catch (Exception e) {
if (!HandleError(e))
{
throw;
}
}
}
