770 lines
28 KiB
C#
770 lines
28 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="PageParser.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Implements the ASP.NET template parser
|
|
*
|
|
* Copyright (c) 1998 Microsoft Corporation
|
|
*/
|
|
|
|
namespace System.Web.UI {
|
|
using System.Runtime.Serialization.Formatters;
|
|
using System.Text;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.Serialization;
|
|
using System;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Reflection;
|
|
using System.Globalization;
|
|
using System.CodeDom.Compiler;
|
|
using System.ComponentModel;
|
|
using System.Web.Hosting;
|
|
using System.Web.Caching;
|
|
using System.Web.Util;
|
|
using System.Web.Compilation;
|
|
using System.Web.Configuration;
|
|
using System.Web.Management;
|
|
using System.EnterpriseServices;
|
|
using HttpException = System.Web.HttpException;
|
|
using System.Text.RegularExpressions;
|
|
using System.Security.Permissions;
|
|
|
|
/*
|
|
* Parser for .aspx files
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public sealed class PageParser : TemplateControlParser {
|
|
|
|
private int _transactionMode = 0 /*TransactionOption.Disabled*/;
|
|
internal int TransactionMode { get { return _transactionMode; } }
|
|
|
|
private TraceMode _traceMode = System.Web.TraceMode.Default;
|
|
internal TraceMode TraceMode { get { return _traceMode; } }
|
|
|
|
private TraceEnable _traceEnabled = TraceEnable.Default;
|
|
internal TraceEnable TraceEnabled { get { return _traceEnabled; } }
|
|
|
|
private int _codePage;
|
|
private string _responseEncoding;
|
|
private int _lcid;
|
|
private string _culture;
|
|
private int _mainDirectiveLineNumber = 1;
|
|
private bool _mainDirectiveMasterPageSet;
|
|
|
|
private OutputCacheLocation _outputCacheLocation;
|
|
|
|
internal bool FRequiresSessionState { get { return flags[requiresSessionState]; } }
|
|
internal bool FReadOnlySessionState { get { return flags[readOnlySessionState]; } }
|
|
|
|
private string _errorPage;
|
|
|
|
private string _styleSheetTheme;
|
|
internal String StyleSheetTheme { get { return _styleSheetTheme; } }
|
|
|
|
internal bool AspCompatMode { get { return flags[aspCompatMode]; } }
|
|
|
|
internal bool AsyncMode { get { return flags[asyncMode]; } }
|
|
|
|
internal bool ValidateRequest { get { return flags[validateRequest]; } }
|
|
|
|
private Type _previousPageType;
|
|
internal Type PreviousPageType { get { return _previousPageType; } }
|
|
|
|
private Type _masterPageType;
|
|
internal Type MasterPageType { get { return _masterPageType; } }
|
|
|
|
private string _configMasterPageFile;
|
|
|
|
|
|
public PageParser() {
|
|
flags[buffer] = Page.BufferDefault;
|
|
flags[requiresSessionState] = true;
|
|
flags[validateRequest] = true;
|
|
}
|
|
|
|
/*
|
|
* Compile an .aspx file into a Page object
|
|
*/
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
|
|
private static object s_lock = new object();
|
|
|
|
|
|
// Only allowed in full trust (ASURT 123086)
|
|
[SecurityPermission(SecurityAction.Demand, Unrestricted=true)]
|
|
public static IHttpHandler GetCompiledPageInstance(string virtualPath,
|
|
string inputFile, HttpContext context) {
|
|
|
|
// Canonicalize the path to avoid failure caused by the CheckSuspiciousPhysicalPath
|
|
// security check, which was not meant to apply to this scenario (plus this API requires
|
|
// full trust). VSWhidbey 541640.
|
|
if (!String.IsNullOrEmpty(inputFile)) {
|
|
inputFile = Path.GetFullPath(inputFile);
|
|
}
|
|
|
|
return GetCompiledPageInstance(VirtualPath.Create(virtualPath), inputFile, context);
|
|
}
|
|
|
|
private static IHttpHandler GetCompiledPageInstance(VirtualPath virtualPath,
|
|
string inputFile, HttpContext context) {
|
|
|
|
// This is a hacky API that only exists to support web service's
|
|
// DefaultWsdlHelpGenerator.aspx, which doesn't live under the app root.
|
|
// To make this work, we add an explicit mapping from the virtual path
|
|
// to the stream of the passed in file
|
|
|
|
// Make it relative to the current request if necessary
|
|
if (context != null)
|
|
virtualPath = context.Request.FilePathObject.Combine(virtualPath);
|
|
|
|
object virtualPathToFileMappingState = null;
|
|
try {
|
|
try {
|
|
// If there is a physical path, we need to connect the virtual path to it, so that
|
|
// the build system will use the right input file for the virtual path.
|
|
if (inputFile != null) {
|
|
virtualPathToFileMappingState = HostingEnvironment.AddVirtualPathToFileMapping(
|
|
virtualPath, inputFile);
|
|
}
|
|
|
|
BuildResultCompiledType result = (BuildResultCompiledType)BuildManager.GetVPathBuildResult(
|
|
context, virtualPath, false /*noBuild*/, true /*allowCrossApp*/, true /*allowBuildInPrecompile*/);
|
|
return (IHttpHandler)HttpRuntime.CreatePublicInstance(result.ResultType);
|
|
}
|
|
finally {
|
|
if (virtualPathToFileMappingState != null)
|
|
HostingEnvironment.ClearVirtualPathToFileMapping(virtualPathToFileMappingState);
|
|
}
|
|
}
|
|
catch {
|
|
throw;
|
|
}
|
|
}
|
|
|
|
internal override Type DefaultBaseType { get { return typeof(System.Web.UI.Page); } }
|
|
|
|
internal override Type DefaultFileLevelBuilderType {
|
|
get {
|
|
return typeof(FileLevelPageControlBuilder);
|
|
}
|
|
}
|
|
|
|
internal override RootBuilder CreateDefaultFileLevelBuilder() {
|
|
|
|
return new FileLevelPageControlBuilder();
|
|
}
|
|
|
|
private void EnsureMasterPageFileFromConfigApplied() {
|
|
// Skip if it's already applied.
|
|
if (_mainDirectiveMasterPageSet) {
|
|
return;
|
|
}
|
|
|
|
// If the masterPageFile is defined in the config
|
|
if (_configMasterPageFile != null) {
|
|
|
|
// Readjust the lineNumber to the location of maindirective
|
|
int prevLineNumber = _lineNumber;
|
|
_lineNumber = _mainDirectiveLineNumber;
|
|
try {
|
|
if (_configMasterPageFile.Length > 0) {
|
|
Type type = GetReferencedType(_configMasterPageFile);
|
|
|
|
// Make sure it has the correct base type
|
|
if (!typeof(MasterPage).IsAssignableFrom(type)) {
|
|
ProcessError(SR.GetString(SR.Invalid_master_base, _configMasterPageFile));
|
|
}
|
|
}
|
|
|
|
if (((FileLevelPageControlBuilder)RootBuilder).ContentBuilderEntries != null) {
|
|
RootBuilder.SetControlType(BaseType);
|
|
RootBuilder.PreprocessAttribute(String.Empty /*filter*/, "MasterPageFile", _configMasterPageFile, true /*mainDirectiveMode*/);
|
|
}
|
|
}
|
|
finally {
|
|
_lineNumber = prevLineNumber;
|
|
}
|
|
}
|
|
|
|
_mainDirectiveMasterPageSet = true;
|
|
}
|
|
|
|
internal override void HandlePostParse() {
|
|
base.HandlePostParse();
|
|
|
|
EnsureMasterPageFileFromConfigApplied();
|
|
}
|
|
|
|
// Get default settings from config
|
|
internal override void ProcessConfigSettings() {
|
|
base.ProcessConfigSettings();
|
|
|
|
if (PagesConfig != null) {
|
|
// Check config for various attributes, and if they have non-default values,
|
|
// set them in _mainDirectiveConfigSettings.
|
|
|
|
if (PagesConfig.Buffer != Page.BufferDefault)
|
|
_mainDirectiveConfigSettings["buffer"] = Util.GetStringFromBool(PagesConfig.Buffer);
|
|
|
|
if (PagesConfig.EnableViewStateMac != Page.EnableViewStateMacDefault)
|
|
_mainDirectiveConfigSettings["enableviewstatemac"] = Util.GetStringFromBool(PagesConfig.EnableViewStateMac);
|
|
|
|
if (PagesConfig.EnableEventValidation != Page.EnableEventValidationDefault)
|
|
_mainDirectiveConfigSettings["enableEventValidation"] = Util.GetStringFromBool(PagesConfig.EnableEventValidation);
|
|
|
|
if (PagesConfig.SmartNavigation != Page.SmartNavigationDefault)
|
|
_mainDirectiveConfigSettings["smartnavigation"] = Util.GetStringFromBool(PagesConfig.SmartNavigation);
|
|
|
|
if (PagesConfig.ThemeInternal != null && PagesConfig.Theme.Length != 0)
|
|
_mainDirectiveConfigSettings["theme"] = PagesConfig.Theme;
|
|
|
|
if (PagesConfig.StyleSheetThemeInternal != null && PagesConfig.StyleSheetThemeInternal.Length != 0)
|
|
_mainDirectiveConfigSettings["stylesheettheme"] = PagesConfig.StyleSheetThemeInternal;
|
|
|
|
if (PagesConfig.MasterPageFileInternal != null && PagesConfig.MasterPageFileInternal.Length != 0) {
|
|
_configMasterPageFile = PagesConfig.MasterPageFileInternal;
|
|
}
|
|
|
|
if (PagesConfig.ViewStateEncryptionMode != Page.EncryptionModeDefault) {
|
|
_mainDirectiveConfigSettings["viewStateEncryptionMode"] = Enum.Format(typeof(ViewStateEncryptionMode), PagesConfig.ViewStateEncryptionMode, "G");
|
|
}
|
|
|
|
if (PagesConfig.MaintainScrollPositionOnPostBack != Page.MaintainScrollPositionOnPostBackDefault) {
|
|
_mainDirectiveConfigSettings["maintainScrollPositionOnPostBack"] = Util.GetStringFromBool(PagesConfig.MaintainScrollPositionOnPostBack);
|
|
}
|
|
|
|
if (PagesConfig.MaxPageStateFieldLength != Page.DefaultMaxPageStateFieldLength) {
|
|
_mainDirectiveConfigSettings["maxPageStateFieldLength"] = PagesConfig.MaxPageStateFieldLength;
|
|
}
|
|
|
|
flags[requiresSessionState] = ((PagesConfig.EnableSessionState == PagesEnableSessionState.True) || (PagesConfig.EnableSessionState == PagesEnableSessionState.ReadOnly));
|
|
flags[readOnlySessionState] = (PagesConfig.EnableSessionState == PagesEnableSessionState.ReadOnly);
|
|
flags[validateRequest] = PagesConfig.ValidateRequest;
|
|
flags[aspCompatMode] = HttpRuntime.ApartmentThreading;
|
|
}
|
|
|
|
ApplyBaseType();
|
|
}
|
|
|
|
private void ApplyBaseType() {
|
|
if (DefaultPageBaseType != null) {
|
|
BaseType = DefaultPageBaseType;
|
|
}
|
|
else if (PagesConfig != null && PagesConfig.PageBaseTypeInternal != null) {
|
|
BaseType = PagesConfig.PageBaseTypeInternal;
|
|
}
|
|
}
|
|
|
|
internal override void ProcessDirective(string directiveName, IDictionary directive) {
|
|
|
|
if (StringUtil.EqualsIgnoreCase(directiveName, "previousPageType")) {
|
|
|
|
if (_previousPageType != null) {
|
|
ProcessError(SR.GetString(SR.Only_one_directive_allowed, directiveName));
|
|
return;
|
|
}
|
|
|
|
_previousPageType = GetDirectiveType(directive, directiveName);
|
|
Util.CheckAssignableType(typeof(Page), _previousPageType);
|
|
}
|
|
else if (StringUtil.EqualsIgnoreCase(directiveName, "masterType")) {
|
|
|
|
if (_masterPageType != null) {
|
|
ProcessError(SR.GetString(SR.Only_one_directive_allowed, directiveName));
|
|
return;
|
|
}
|
|
|
|
_masterPageType = GetDirectiveType(directive, directiveName);
|
|
Util.CheckAssignableType(typeof(MasterPage), _masterPageType);
|
|
}
|
|
else {
|
|
base.ProcessDirective(directiveName, directive);
|
|
}
|
|
}
|
|
|
|
// Override to get the location of maindirective.
|
|
internal override void ProcessMainDirective(IDictionary mainDirective) {
|
|
// Remember the location of the main directive.
|
|
_mainDirectiveLineNumber = _lineNumber;
|
|
|
|
base.ProcessMainDirective(mainDirective);
|
|
}
|
|
|
|
internal override bool ProcessMainDirectiveAttribute(string deviceName, string name,
|
|
string value, IDictionary parseData) {
|
|
|
|
switch (name) {
|
|
|
|
case "errorpage":
|
|
_errorPage = Util.GetNonEmptyAttribute(name, value);
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "contenttype":
|
|
// Check validity
|
|
Util.GetNonEmptyAttribute(name, value);
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "theme":
|
|
if (IsExpressionBuilderValue(value)) {
|
|
return false;
|
|
}
|
|
|
|
// Check validity
|
|
Util.CheckThemeAttribute(value);
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "stylesheettheme":
|
|
// Make sure no device filter or expression builder was specified
|
|
ValidateBuiltInAttribute(deviceName, name, value);
|
|
|
|
// Check validity
|
|
Util.CheckThemeAttribute(value);
|
|
|
|
_styleSheetTheme = value;
|
|
return true;
|
|
|
|
case "enablesessionstate":
|
|
flags[requiresSessionState] = true;
|
|
flags[readOnlySessionState] = false;
|
|
if (Util.IsFalseString(value)) {
|
|
flags[requiresSessionState] = false;
|
|
}
|
|
else if (StringUtil.EqualsIgnoreCase(value, "readonly")) {
|
|
flags[readOnlySessionState] = true;
|
|
}
|
|
else if (!Util.IsTrueString(value)) {
|
|
ProcessError(SR.GetString(SR.Enablesessionstate_must_be_true_false_or_readonly));
|
|
}
|
|
|
|
if (flags[requiresSessionState]) {
|
|
// Session state is only available for compiled pages
|
|
OnFoundAttributeRequiringCompilation(name);
|
|
}
|
|
break;
|
|
|
|
case "culture":
|
|
_culture = Util.GetNonEmptyAttribute(name, value);
|
|
|
|
// Setting culture requires medium permission
|
|
if (!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium)) {
|
|
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "culture"));
|
|
}
|
|
|
|
//do not verify at parse time if potentially using browser AutoDetect
|
|
if(StringUtil.EqualsIgnoreCase(value, HttpApplication.AutoCulture)) {
|
|
return false;
|
|
}
|
|
|
|
|
|
// Create a CultureInfo just to verify validity
|
|
CultureInfo cultureInfo;
|
|
|
|
try {
|
|
if(StringUtil.StringStartsWithIgnoreCase(value, HttpApplication.AutoCulture)) {
|
|
//safe to trim leading "auto:", string used elsewhere for null check
|
|
_culture = _culture.Substring(5);
|
|
}
|
|
cultureInfo = HttpServerUtility.CreateReadOnlyCultureInfo(_culture);
|
|
}
|
|
catch {
|
|
ProcessError(SR.GetString(SR.Invalid_attribute_value, _culture, "culture"));
|
|
return false;
|
|
}
|
|
|
|
// Don't allow neutral cultures (ASURT 77930)
|
|
if (cultureInfo.IsNeutralCulture) {
|
|
ProcessError(SR.GetString(SR.Invalid_culture_attribute,
|
|
Util.GetSpecificCulturesFormattedList(cultureInfo)));
|
|
}
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "lcid":
|
|
// Skip validity check for expression builder (e.g. <%$ ... %>)
|
|
if (IsExpressionBuilderValue(value)) return false;
|
|
|
|
_lcid = Util.GetNonNegativeIntegerAttribute(name, value);
|
|
|
|
// Create a CultureInfo just to verify validity
|
|
try {
|
|
HttpServerUtility.CreateReadOnlyCultureInfo(_lcid);
|
|
}
|
|
catch {
|
|
ProcessError(SR.GetString(SR.Invalid_attribute_value,
|
|
_lcid.ToString(CultureInfo.InvariantCulture), "lcid"));
|
|
}
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "uiculture":
|
|
// Check validity
|
|
Util.GetNonEmptyAttribute(name, value);
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "responseencoding":
|
|
// Skip validity check for expression builder (e.g. <%$ ... %>)
|
|
if (IsExpressionBuilderValue(value)) return false;
|
|
|
|
_responseEncoding = Util.GetNonEmptyAttribute(name, value);
|
|
|
|
// Call Encoding.GetEncoding just to verify validity
|
|
Encoding.GetEncoding(_responseEncoding);
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "codepage":
|
|
// Skip validity check for expression builder (e.g. <%$ ... %>)
|
|
if (IsExpressionBuilderValue(value)) return false;
|
|
|
|
_codePage = Util.GetNonNegativeIntegerAttribute(name, value);
|
|
|
|
// Call Encoding.GetEncoding just to verify validity
|
|
Encoding.GetEncoding(_codePage);
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "transaction":
|
|
// This only makes sense for compiled pages
|
|
OnFoundAttributeRequiringCompilation(name);
|
|
|
|
ParseTransactionAttribute(name, value);
|
|
break;
|
|
|
|
case "aspcompat":
|
|
// This only makes sense for compiled pages
|
|
OnFoundAttributeRequiringCompilation(name);
|
|
|
|
flags[aspCompatMode] = Util.GetBooleanAttribute(name, value);
|
|
|
|
// Only allow the use of aspcompat when we have UnmanagedCode access (ASURT 76694)
|
|
if (flags[aspCompatMode] && !HttpRuntime.HasUnmanagedPermission()) {
|
|
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "AspCompat"));
|
|
}
|
|
|
|
break;
|
|
|
|
case "async":
|
|
// This only makes sense for compiled pages
|
|
OnFoundAttributeRequiringCompilation(name);
|
|
|
|
flags[asyncMode] = Util.GetBooleanAttribute(name, value);
|
|
|
|
// Async requires Medium trust
|
|
if (!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium)) {
|
|
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "async"));
|
|
}
|
|
|
|
break;
|
|
|
|
case "tracemode":
|
|
// We use TraceModeInternal instead of TraceMode to disallow the 'default' value (ASURT 75783)
|
|
object tmpObj = Util.GetEnumAttribute(name, value, typeof(TraceModeInternal));
|
|
_traceMode = (TraceMode) tmpObj;
|
|
break;
|
|
|
|
case "trace":
|
|
bool traceEnabled = Util.GetBooleanAttribute(name, value);
|
|
if (traceEnabled)
|
|
_traceEnabled = TraceEnable.Enable;
|
|
else
|
|
_traceEnabled = TraceEnable.Disable;
|
|
break;
|
|
|
|
case "smartnavigation":
|
|
// Make sure no device filter or expression builder was specified, since it doesn't make much
|
|
// sense for smartnav (which only works on IE5.5+) (VSWhidbey 85876)
|
|
ValidateBuiltInAttribute(deviceName, name, value);
|
|
|
|
// Ignore it if it has default value. Otherwise, let the generic
|
|
// attribute processing continue
|
|
bool smartNavigation = Util.GetBooleanAttribute(name, value);
|
|
return (smartNavigation == Page.SmartNavigationDefault);
|
|
|
|
case "maintainscrollpositiononpostback":
|
|
bool maintainScrollPosition = Util.GetBooleanAttribute(name, value);
|
|
return (maintainScrollPosition == Page.MaintainScrollPositionOnPostBackDefault);
|
|
|
|
case "validaterequest":
|
|
flags[validateRequest] = Util.GetBooleanAttribute(name, value);
|
|
break;
|
|
|
|
case "clienttarget":
|
|
// Skip validity check for expression builder (e.g. <%$ ... %>)
|
|
if (IsExpressionBuilderValue(value)) return false;
|
|
|
|
// Check validity
|
|
HttpCapabilitiesDefaultProvider.GetUserAgentFromClientTarget(CurrentVirtualPath, value);
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
case "masterpagefile":
|
|
// Skip validity check for expression builder (e.g. <%$ ... %>)
|
|
if (IsExpressionBuilderValue(value)) return false;
|
|
|
|
if (value.Length > 0) {
|
|
// Add dependency on the Type by calling this method
|
|
Type type = GetReferencedType(value);
|
|
|
|
// Make sure it has the correct base type
|
|
if (!typeof(MasterPage).IsAssignableFrom(type)) {
|
|
ProcessError(SR.GetString(SR.Invalid_master_base, value));
|
|
}
|
|
|
|
if (deviceName.Length > 0) {
|
|
// Make sure the masterPageFile definition from config
|
|
// is applied before filtered masterPageFile attributes.
|
|
EnsureMasterPageFileFromConfigApplied();
|
|
}
|
|
}
|
|
|
|
//VSWhidbey 479064 Remember the masterPageFile had been set even if it's empty string
|
|
_mainDirectiveMasterPageSet = true;
|
|
|
|
// Return false to let the generic attribute processing continue
|
|
return false;
|
|
|
|
default:
|
|
// We didn't handle the attribute. Try the base class
|
|
return base.ProcessMainDirectiveAttribute(deviceName, name, value, parseData);
|
|
}
|
|
|
|
// The attribute was handled
|
|
|
|
// Make sure no device filter or resource expression was specified
|
|
ValidateBuiltInAttribute(deviceName, name, value);
|
|
|
|
return true;
|
|
}
|
|
|
|
internal override void ProcessUnknownMainDirectiveAttribute(string filter, string attribName, string value) {
|
|
|
|
// asynctimeout is in seconds while the corresponding public page property is a timespan
|
|
// this requires a patch-up
|
|
if (attribName == "asynctimeout") {
|
|
int timeoutInSeconds = Util.GetNonNegativeIntegerAttribute(attribName, value);
|
|
value = (new TimeSpan(0, 0, timeoutInSeconds)).ToString();
|
|
}
|
|
|
|
base.ProcessUnknownMainDirectiveAttribute(filter, attribName, value);
|
|
}
|
|
|
|
internal override void PostProcessMainDirectiveAttributes(IDictionary parseData) {
|
|
|
|
// Can't have an error page if buffering is off
|
|
if (!flags[buffer] && _errorPage != null) {
|
|
ProcessError(SR.GetString(SR.Error_page_not_supported_when_buffering_off));
|
|
return;
|
|
}
|
|
|
|
if (_culture != null && _lcid > 0) {
|
|
ProcessError(SR.GetString(SR.Attributes_mutually_exclusive, "Culture", "LCID"));
|
|
return;
|
|
}
|
|
|
|
if (_responseEncoding != null && _codePage > 0) {
|
|
ProcessError(SR.GetString(SR.Attributes_mutually_exclusive, "ResponseEncoding", "CodePage"));
|
|
return;
|
|
}
|
|
|
|
// async can't be combined with aspcompat
|
|
if (AsyncMode && AspCompatMode) {
|
|
ProcessError(SR.GetString(SR.Async_and_aspcompat));
|
|
return;
|
|
}
|
|
|
|
// async can't be combined with transactions
|
|
if (AsyncMode && _transactionMode != 0) {
|
|
ProcessError(SR.GetString(SR.Async_and_transaction));
|
|
return;
|
|
}
|
|
|
|
// Let the base class do its post processing
|
|
base.PostProcessMainDirectiveAttributes(parseData);
|
|
}
|
|
|
|
private enum TraceModeInternal {
|
|
SortByTime = 0,
|
|
SortByCategory = 1
|
|
}
|
|
|
|
// This must be in its own method to avoid jitting System.EnterpriseServices.dll
|
|
// when it is not needed (ASURT 71868)
|
|
private void ParseTransactionAttribute(string name, string value) {
|
|
object tmpObj = Util.GetEnumAttribute(name, value, typeof(TransactionOption));
|
|
if (tmpObj != null) {
|
|
_transactionMode = (int) tmpObj;
|
|
|
|
// Add a reference to the transaction assembly only if needed
|
|
if (_transactionMode != 0 /*TransactionOption.Disabled*/) {
|
|
|
|
if (!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium)) {
|
|
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "transaction"));
|
|
}
|
|
|
|
AddAssemblyDependency(typeof(TransactionOption).Assembly);
|
|
}
|
|
}
|
|
}
|
|
|
|
internal const string defaultDirectiveName = "page";
|
|
internal override string DefaultDirectiveName {
|
|
get { return defaultDirectiveName; }
|
|
}
|
|
|
|
/*
|
|
* Process the contents of the <%@ OutputCache ... %> directive
|
|
*/
|
|
internal override void ProcessOutputCacheDirective(string directiveName, IDictionary directive) {
|
|
string varyByContentEncoding;
|
|
string varyByHeader;
|
|
string sqlDependency;
|
|
bool noStoreValue = false;
|
|
|
|
varyByContentEncoding = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycontentencoding");
|
|
if (varyByContentEncoding != null) {
|
|
OutputCacheParameters.VaryByContentEncoding = varyByContentEncoding;
|
|
}
|
|
|
|
varyByHeader = Util.GetAndRemoveNonEmptyAttribute(directive, "varybyheader");
|
|
if (varyByHeader != null) {
|
|
OutputCacheParameters.VaryByHeader = varyByHeader;
|
|
}
|
|
|
|
object tmpObj = Util.GetAndRemoveEnumAttribute(directive, typeof(OutputCacheLocation), "location");
|
|
if (tmpObj != null) {
|
|
_outputCacheLocation = (OutputCacheLocation) tmpObj;
|
|
OutputCacheParameters.Location = _outputCacheLocation;
|
|
}
|
|
|
|
sqlDependency = Util.GetAndRemoveNonEmptyAttribute(directive, "sqldependency");
|
|
if (sqlDependency != null) {
|
|
OutputCacheParameters.SqlDependency = sqlDependency;
|
|
// Validate the sqldependency attribute
|
|
SqlCacheDependency.ValidateOutputCacheDependencyString(sqlDependency, true);
|
|
}
|
|
|
|
// Get the "no store" bool value
|
|
if (Util.GetAndRemoveBooleanAttribute(directive, "nostore", ref noStoreValue)) {
|
|
OutputCacheParameters.NoStore = noStoreValue;
|
|
}
|
|
|
|
base.ProcessOutputCacheDirective(directiveName, directive);
|
|
}
|
|
|
|
|
|
private static Type s_defaultPageBaseType;
|
|
|
|
public static Type DefaultPageBaseType {
|
|
get {
|
|
return s_defaultPageBaseType;
|
|
}
|
|
set {
|
|
if (value != null && !typeof(Page).IsAssignableFrom(value)) {
|
|
throw ExceptionUtil.PropertyInvalid("DefaultPageBaseType");
|
|
}
|
|
BuildManager.ThrowIfPreAppStartNotRunning();
|
|
|
|
s_defaultPageBaseType = value;
|
|
}
|
|
}
|
|
|
|
private static Type s_defaultUserContorlBaseType;
|
|
|
|
public static Type DefaultUserControlBaseType {
|
|
get {
|
|
return s_defaultUserContorlBaseType;
|
|
}
|
|
set {
|
|
if (value != null && !typeof(UserControl).IsAssignableFrom(value)) {
|
|
throw ExceptionUtil.PropertyInvalid("DefaultUserControlBaseType");
|
|
}
|
|
BuildManager.ThrowIfPreAppStartNotRunning();
|
|
|
|
s_defaultUserContorlBaseType = value;
|
|
}
|
|
}
|
|
|
|
private static Type s_defaultApplicationBaseType;
|
|
|
|
public static Type DefaultApplicationBaseType {
|
|
get {
|
|
return s_defaultApplicationBaseType;
|
|
}
|
|
set {
|
|
if (value != null && !typeof(HttpApplication).IsAssignableFrom(value)) {
|
|
throw ExceptionUtil.PropertyInvalid("DefaultApplicationBaseType");
|
|
}
|
|
BuildManager.ThrowIfPreAppStartNotRunning();
|
|
|
|
s_defaultApplicationBaseType = value;
|
|
}
|
|
}
|
|
|
|
private static Type s_defaultPageParserFilterType;
|
|
|
|
public static Type DefaultPageParserFilterType {
|
|
get {
|
|
return s_defaultPageParserFilterType;
|
|
}
|
|
set {
|
|
if (value != null && !typeof(PageParserFilter).IsAssignableFrom(value)) {
|
|
throw ExceptionUtil.PropertyInvalid("DefaultPageParserFilterType");
|
|
}
|
|
BuildManager.ThrowIfPreAppStartNotRunning();
|
|
|
|
s_defaultPageParserFilterType = value;
|
|
}
|
|
}
|
|
|
|
private static bool s_enableLongStringsAsResources = true;
|
|
|
|
public static bool EnableLongStringsAsResources {
|
|
get {
|
|
return s_enableLongStringsAsResources;
|
|
}
|
|
set {
|
|
BuildManager.ThrowIfPreAppStartNotRunning();
|
|
s_enableLongStringsAsResources = value;
|
|
}
|
|
}
|
|
|
|
internal override bool FDurationRequiredOnOutputCache {
|
|
get { return _outputCacheLocation != OutputCacheLocation.None; }
|
|
}
|
|
|
|
internal override bool FVaryByParamsRequiredOnOutputCache {
|
|
get { return _outputCacheLocation != OutputCacheLocation.None; }
|
|
}
|
|
|
|
internal override string UnknownOutputCacheAttributeError {
|
|
get { return SR.Attr_not_supported_in_pagedirective; }
|
|
}
|
|
}
|
|
|
|
}
|