385 lines
14 KiB
C#
385 lines
14 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="TemplateControlParser.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.Text;
|
|
using System;
|
|
using System.IO;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.ComponentModel;
|
|
using System.ComponentModel.Design;
|
|
using System.Reflection;
|
|
using System.Configuration;
|
|
using System.Web.Caching;
|
|
using System.Web.Util;
|
|
using System.Web.Compilation;
|
|
using HttpException = System.Web.HttpException;
|
|
using System.Text.RegularExpressions;
|
|
using System.Globalization;
|
|
using System.Security.Permissions;
|
|
|
|
|
|
/*
|
|
* Parser for TemplateControl's (UserControls and Pages)
|
|
*/
|
|
|
|
/// <internalonly/>
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public abstract class TemplateControlParser : BaseTemplateParser {
|
|
|
|
// Attributes in <%@ outputcache ... %> directive
|
|
private IDictionary _outputCacheDirective;
|
|
|
|
private OutputCacheParameters _outputCacheSettings;
|
|
internal OutputCacheParameters OutputCacheParameters { get { return _outputCacheSettings; } }
|
|
|
|
internal bool FAutoEventWireup { get { return !flags[noAutoEventWireup]; } }
|
|
|
|
internal override bool RequiresCompilation {
|
|
get { return flags[requiresCompilation] || CompilationMode == CompilationMode.Always; }
|
|
}
|
|
|
|
// Get default settings from config
|
|
internal override void ProcessConfigSettings() {
|
|
base.ProcessConfigSettings();
|
|
|
|
if (PagesConfig != null) {
|
|
flags[noAutoEventWireup] = !PagesConfig.AutoEventWireup;
|
|
|
|
// If config has a non-default EnableViewState value, set it in the main directive
|
|
if (PagesConfig.EnableViewState != Control.EnableViewStateDefault)
|
|
_mainDirectiveConfigSettings["enableviewstate"] = Util.GetStringFromBool(PagesConfig.EnableViewState);
|
|
|
|
CompilationMode = PagesConfig.CompilationMode;
|
|
}
|
|
|
|
// if there is a filter, ask it if it wants to use a different mode
|
|
if (_pageParserFilter != null)
|
|
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
|
|
}
|
|
|
|
internal override void ProcessDirective(string directiveName, IDictionary directive) {
|
|
|
|
if (StringUtil.EqualsIgnoreCase(directiveName, "outputcache")) {
|
|
|
|
// Ignore the OutputCache directive in design mode (VSWhidbey 470314)
|
|
if (FInDesigner)
|
|
return;
|
|
|
|
if (_outputCacheSettings == null) {
|
|
_outputCacheSettings = new OutputCacheParameters();
|
|
}
|
|
|
|
// Make sure the outputcache directive was not already specified
|
|
if (_outputCacheDirective != null) {
|
|
throw new HttpException(
|
|
SR.GetString(SR.Only_one_directive_allowed, directiveName));
|
|
}
|
|
|
|
ProcessOutputCacheDirective(directiveName, directive);
|
|
|
|
_outputCacheDirective = directive;
|
|
}
|
|
else if (StringUtil.EqualsIgnoreCase(directiveName, "reference")) {
|
|
|
|
// Ignore the OutputCache directive in design mode (VSWhidbey 517783)
|
|
if (FInDesigner) {
|
|
return;
|
|
}
|
|
|
|
// Even though this only makes sense for compiled pages, Sharepoint needs us to
|
|
// ignore instead of throw when the page in non-compiled.
|
|
|
|
|
|
// For historical reasons, the virtual path can be specified by 3 different attributes:
|
|
// virtualpath, page and control. They all do the same, and virtualpath is the recommended
|
|
// one (the other two are deprecated).
|
|
|
|
// Make sure that no more than one is specified.
|
|
|
|
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualpath");
|
|
|
|
bool enforcePage = false;
|
|
bool enforceControl = false;
|
|
|
|
VirtualPath tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "page");
|
|
if (tmp != null) {
|
|
if (virtualPath != null) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive));
|
|
return;
|
|
}
|
|
virtualPath = tmp;
|
|
enforcePage = true;
|
|
}
|
|
|
|
tmp = Util.GetAndRemoveVirtualPathAttribute(directive, "control");
|
|
if (tmp != null) {
|
|
if (virtualPath != null) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive));
|
|
return;
|
|
}
|
|
virtualPath = tmp;
|
|
enforceControl = true;
|
|
}
|
|
|
|
// If we didn't get a virtual path, fail
|
|
if (virtualPath == null) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive));
|
|
return;
|
|
}
|
|
|
|
Type t = GetReferencedType(virtualPath);
|
|
|
|
if (t == null) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
|
|
}
|
|
|
|
// If the 'page' attribute was used, make sure it's indeed a Page
|
|
if (enforcePage && !typeof(Page).IsAssignableFrom(t)) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
|
|
}
|
|
|
|
// If the 'control' attribute was used, make sure it's indeed a UserControl
|
|
if (enforceControl && !typeof(UserControl).IsAssignableFrom(t)) {
|
|
ProcessError(SR.GetString(SR.Invalid_reference_directive_attrib, virtualPath));
|
|
}
|
|
|
|
// If there are some attributes left, fail
|
|
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
|
|
}
|
|
else {
|
|
base.ProcessDirective(directiveName, directive);
|
|
}
|
|
}
|
|
|
|
internal override void ProcessMainDirective(IDictionary mainDirective) {
|
|
|
|
// We want to make sure that we process the compilationmode attribute before any
|
|
// of the other main directive attributes, since its presence can cause other
|
|
// attributes to be illegal. So we handle it instead of in ProcessMainDirectiveAttribute.
|
|
object tmpObj = null;
|
|
|
|
try {
|
|
tmpObj = Util.GetAndRemoveEnumAttribute(mainDirective,
|
|
typeof(CompilationMode), "compilationmode");
|
|
}
|
|
// catch the exception here so we can continue to process the rest of the main directive
|
|
// when called from CBM
|
|
catch (Exception ex) {
|
|
ProcessError(ex.Message);
|
|
}
|
|
|
|
if (tmpObj != null) {
|
|
CompilationMode = (CompilationMode) tmpObj;
|
|
|
|
// if there is a filter, ask it if it wants to use a different mode
|
|
if (_pageParserFilter != null)
|
|
CompilationMode = _pageParserFilter.GetCompilationMode(CompilationMode);
|
|
}
|
|
|
|
base.ProcessMainDirective(mainDirective);
|
|
}
|
|
|
|
internal override bool ProcessMainDirectiveAttribute(string deviceName, string name,
|
|
string value, IDictionary parseData) {
|
|
|
|
switch (name) {
|
|
|
|
// Ignore 'targetschema' attribute (ASURT 85670)
|
|
case "targetschema":
|
|
break;
|
|
|
|
case "autoeventwireup":
|
|
// This only makes sense for compiled pages
|
|
OnFoundAttributeRequiringCompilation(name);
|
|
|
|
flags[noAutoEventWireup] = !Util.GetBooleanAttribute(name, value);
|
|
break;
|
|
|
|
case "enabletheming":
|
|
// Return false to let the generic attribute processing continue
|
|
// which will cause the EnableTheming property to be set on the
|
|
// TemplateControl instance.
|
|
return false;
|
|
|
|
case CodeFileBaseClassAttributeName:
|
|
// Remember the base class for post processing
|
|
parseData[name] = Util.GetNonEmptyAttribute(name, value);
|
|
break;
|
|
|
|
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) {
|
|
|
|
// Don't allow the id to be specified on the directive, even though it is
|
|
// a public member of the control class (VSWhidbey 85384)
|
|
if (attribName == "id") {
|
|
base.ProcessUnknownMainDirectiveAttribute(filter, attribName, value);
|
|
return;
|
|
}
|
|
|
|
// Process unknown attributes as regular control attribute, hence allowing
|
|
// arbitrary properties of the base class to be set.
|
|
// But turn off IAttributeAccessor support, otherwise any bad string on a
|
|
// user control's directive won't be caught.
|
|
|
|
try {
|
|
RootBuilder.PreprocessAttribute(filter, attribName, value, true /*mainDirectiveMode*/);
|
|
}
|
|
catch (Exception e) {
|
|
ProcessError(SR.GetString(SR.Attrib_parse_error, attribName, e.Message));
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Add assembly dependencies for a collection of static objects
|
|
*/
|
|
private void AddStaticObjectAssemblyDependencies(HttpStaticObjectsCollection staticObjects) {
|
|
if (staticObjects == null || staticObjects.Objects == null) return;
|
|
|
|
IDictionaryEnumerator en = staticObjects.Objects.GetEnumerator();
|
|
while (en.MoveNext()) {
|
|
HttpStaticObjectsEntry entry = (HttpStaticObjectsEntry)en.Value;
|
|
|
|
AddTypeDependency(entry.ObjectType);
|
|
}
|
|
}
|
|
|
|
internal Type GetDirectiveType(IDictionary directive, string directiveName) {
|
|
string typeName = Util.GetAndRemoveNonEmptyNoSpaceAttribute(directive, "typeName");
|
|
VirtualPath virtualPath = Util.GetAndRemoveVirtualPathAttribute(directive, "virtualPath");
|
|
|
|
Type resultType = null;
|
|
|
|
// If neither or both are specified, fail
|
|
if ((typeName == null) == (virtualPath == null)) {
|
|
throw new HttpException(SR.GetString(SR.Invalid_typeNameOrVirtualPath_directive, directiveName));
|
|
}
|
|
|
|
if (typeName != null) {
|
|
resultType = GetType(typeName);
|
|
AddTypeDependency(resultType);
|
|
}
|
|
else {
|
|
resultType = GetReferencedType(virtualPath);
|
|
}
|
|
|
|
// If there are some attributes left, fail
|
|
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
|
|
|
|
return resultType;
|
|
}
|
|
|
|
internal override void HandlePostParse() {
|
|
base.HandlePostParse();
|
|
|
|
if (!FInDesigner) {
|
|
// Omit AutoEventWireup if there can't possibly be any events defined (ASURT 97772)
|
|
if (ScriptList.Count == 0 && BaseType == DefaultBaseType && CodeFileVirtualPath == null)
|
|
flags[noAutoEventWireup] = true;
|
|
|
|
_applicationObjects = HttpApplicationFactory.ApplicationState.StaticObjects;
|
|
AddStaticObjectAssemblyDependencies(_applicationObjects);
|
|
|
|
_sessionObjects = HttpApplicationFactory.ApplicationState.SessionStaticObjects;
|
|
AddStaticObjectAssemblyDependencies(_sessionObjects);
|
|
}
|
|
}
|
|
|
|
/*
|
|
* Process the contents of the <%@ OutputCache ... %> directive
|
|
*/
|
|
internal virtual void ProcessOutputCacheDirective(string directiveName, IDictionary directive) {
|
|
int duration = 0; // Unit is second
|
|
string varyByParams;
|
|
string varyByCustom;
|
|
string outputCacheProfile = null;
|
|
string varyByControls;
|
|
|
|
bool fHasDuration = Util.GetAndRemovePositiveIntegerAttribute(directive, "duration", ref duration);
|
|
if (fHasDuration) {
|
|
OutputCacheParameters.Duration = duration;
|
|
}
|
|
|
|
//
|
|
if (this is PageParser) {
|
|
outputCacheProfile = Util.GetAndRemoveNonEmptyAttribute(directive, "cacheProfile");
|
|
if (outputCacheProfile != null) {
|
|
OutputCacheParameters.CacheProfile = outputCacheProfile;
|
|
}
|
|
}
|
|
|
|
if (!fHasDuration && (outputCacheProfile == null || outputCacheProfile.Length == 0) && FDurationRequiredOnOutputCache)
|
|
throw new HttpException(SR.GetString(SR.Missing_attr, "duration"));
|
|
|
|
varyByCustom = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycustom");
|
|
if (varyByCustom != null) {
|
|
OutputCacheParameters.VaryByCustom = varyByCustom;
|
|
}
|
|
|
|
varyByControls = Util.GetAndRemoveNonEmptyAttribute(directive, "varybycontrol");
|
|
if (varyByControls != null) {
|
|
OutputCacheParameters.VaryByControl = varyByControls;
|
|
}
|
|
|
|
varyByParams = Util.GetAndRemoveNonEmptyAttribute(directive, "varybyparam");
|
|
if (varyByParams != null) {
|
|
OutputCacheParameters.VaryByParam = varyByParams;
|
|
}
|
|
|
|
// VaryByParams is required (ASURT 76763)
|
|
if (varyByParams == null &&
|
|
varyByControls == null &&
|
|
(outputCacheProfile == null || outputCacheProfile.Length == 0) &&
|
|
FVaryByParamsRequiredOnOutputCache)
|
|
throw new HttpException(SR.GetString(SR.Missing_varybyparam_attr));
|
|
|
|
// If it's "none", set it to null
|
|
if (StringUtil.EqualsIgnoreCase(varyByParams, "none"))
|
|
OutputCacheParameters.VaryByParam = null;
|
|
|
|
if (StringUtil.EqualsIgnoreCase(varyByControls, "none"))
|
|
OutputCacheParameters.VaryByControl = null;
|
|
|
|
// If there are some attributes left, fail
|
|
Util.CheckUnknownDirectiveAttributes(directiveName, directive, UnknownOutputCacheAttributeError);
|
|
}
|
|
|
|
internal virtual bool FDurationRequiredOnOutputCache {
|
|
get { return true; }
|
|
}
|
|
|
|
internal virtual bool FVaryByParamsRequiredOnOutputCache {
|
|
get { return true; }
|
|
}
|
|
|
|
internal abstract string UnknownOutputCacheAttributeError {
|
|
get;
|
|
}
|
|
}
|
|
}
|