Files
mono/mcs/class/referencesource/System.Web/UI/SimpleWebHandlerParser.cs
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
Adding reference source for
System.Data
System.Data.DataSetExtensions
System.Data.Entity
System.Data.Entity.Design
System.Data.Linq
System.Data.SqlXml
System.ServiceModel
System.ServiceModel.Activation
System.ServiceModel.Activities
System.ServiceModel.Channels
System.ServiceModel.Discovery
System.ServiceModel.Internals
System.ServiceModel.Routing
System.ServiceModel.WasHosting
System.ServiceModel.Web
System.Web
System.Web.ApplicationServices
System.Web.DynamicData
System.Web.Entity
System.Web.Entity.Design
System.Web.Extensions
System.Web.Mobile
System.Web.Routing
System.Web.Services
System.Xml
System.Xml.Linq
2016-05-03 00:07:37 +02:00

562 lines
18 KiB
C#

//------------------------------------------------------------------------------
// <copyright file="SimpleWebHandlerParser.cs" company="Microsoft">
// Copyright (c) Microsoft Corporation. All rights reserved.
// </copyright>
//------------------------------------------------------------------------------
/*
* Implements the parser for simple web handler files
*
* Copyright (c) 2000 Microsoft Corporation
*/
namespace System.Web.UI {
using System.Runtime.Serialization.Formatters;
using System.Text;
using System.Runtime.Serialization;
using System;
using System.Reflection;
using System.IO;
using System.Collections;
using System.Collections.Specialized;
using System.Text.RegularExpressions;
using System.CodeDom.Compiler;
using System.Web;
using System.Web.Hosting;
using System.Web.Caching;
using System.Web.Compilation;
using System.CodeDom;
using System.Web.Util;
using Debug=System.Web.Util.Debug;
using System.Web.RegularExpressions;
using System.Globalization;
using System.Security.Permissions;
/// <internalonly/>
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public abstract class SimpleWebHandlerParser : IAssemblyDependencyParser {
private readonly static Regex directiveRegex = new SimpleDirectiveRegex();
private SimpleHandlerBuildProvider _buildProvider;
private TextReader _reader;
private VirtualPath _virtualPath;
// The line number in file currently being parsed
private int _lineNumber;
// The column number in file currently being parsed
private int _startColumn;
private bool _fFoundMainDirective;
private string _typeName;
internal string TypeName {
get { return _typeName; }
}
private CompilerType _compilerType;
// The string containing the code to be compiled
private string _sourceString;
// Assemblies to be linked with
private AssemblySet _linkedAssemblies;
// The set of assemblies that the build system is telling us we will be linked with
private ICollection _referencedAssemblies;
private static char[] s_newlineChars = new char[] { '\r', '\n' };
private bool _ignoreParseErrors;
internal bool IgnoreParseErrors {
get { return _ignoreParseErrors; }
set { _ignoreParseErrors = value; }
}
internal void SetBuildProvider(SimpleHandlerBuildProvider buildProvider) {
_buildProvider = buildProvider;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
// Only allowed in full trust (ASURT 124397)
[SecurityPermission(SecurityAction.Demand, Unrestricted=true)]
protected SimpleWebHandlerParser(HttpContext context, string virtualPath, string physicalPath) {
// These obsolete parameters should never be set
Debug.Assert(context == null);
Debug.Assert(physicalPath == null);
Debug.Assert(virtualPath != null);
_virtualPath = VirtualPath.Create(virtualPath);
}
/*
* Compile a web handler file into a Type. Result is cached.
*/
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected Type GetCompiledTypeFromCache() {
//
// This method is practically useless, but cannot be removed to avoid a breaking change
//
BuildResultCompiledType result = (BuildResultCompiledType) BuildManager.GetVPathBuildResult(_virtualPath);
return result.ResultType;
}
internal void Parse(ICollection referencedAssemblies) {
_referencedAssemblies = referencedAssemblies;
AddSourceDependency(_virtualPath);
// Open a TextReader for the virtualPath we're parsing
using (_reader = _buildProvider.OpenReaderInternal()) {
ParseReader();
}
}
internal CompilerType CompilerType { get { return _compilerType; } }
internal ICollection AssemblyDependencies { get { return _linkedAssemblies; } }
private StringSet _sourceDependencies;
internal ICollection SourceDependencies { get { return _sourceDependencies; } }
internal CodeCompileUnit GetCodeModel() {
// Do we have something to compile?
if (_sourceString == null)
return null;
CodeSnippetCompileUnit snippetCompileUnit = new CodeSnippetCompileUnit(_sourceString);
// Put in some context so that the file can be debugged.
snippetCompileUnit.LinePragma = BaseCodeDomTreeGenerator.CreateCodeLinePragmaHelper(
_virtualPath.VirtualPathString, _lineNumber);
return snippetCompileUnit;
}
internal IDictionary GetLinePragmasTable() {
LinePragmaCodeInfo codeInfo = new LinePragmaCodeInfo();
codeInfo._startLine = _lineNumber;
codeInfo._startColumn = _startColumn;
codeInfo._startGeneratedColumn = 1;
codeInfo._codeLength = -1;
codeInfo._isCodeNugget = false;
IDictionary linePragmasTable = new Hashtable();
linePragmasTable[_lineNumber] = codeInfo;
return linePragmasTable;
}
internal bool HasInlineCode { get { return (_sourceString != null); } }
internal Type GetTypeToCache(Assembly builtAssembly) {
Type t = null;
// First, try to get the type from the assembly that has been built (if any)
if (builtAssembly != null)
t = builtAssembly.GetType(_typeName);
// If not, try to get it from other assemblies
if (t == null)
t = GetType(_typeName);
// Make sure the type derives from what we expect
try {
ValidateBaseType(t);
}
catch (Exception e) {
throw new HttpParseException(e.Message, e, _virtualPath, _sourceString, _lineNumber);
}
return t;
}
internal virtual void ValidateBaseType(Type t) {
// No restriction on the base type by default
}
/*
* Parse the contents of the TextReader
*/
private void ParseReader() {
string s = _reader.ReadToEnd();
try {
ParseString(s);
}
catch (Exception e) {
throw new HttpParseException(e.Message, e, _virtualPath, s, _lineNumber);
}
}
/*
* Parse the contents of the string
*/
private void ParseString(string text) {
int textPos = 0;
Match match;
_lineNumber = 1;
// First, parse all the <%@ ... %> directives
for (;;) {
match = directiveRegex.Match(text, textPos);
// Done with the directives?
if (!match.Success)
break;
_lineNumber += Util.LineCount(text, textPos, match.Index);
textPos = match.Index;
// Get all the directives into a bag
IDictionary directive = CollectionsUtil.CreateCaseInsensitiveSortedList();
string directiveName = ProcessAttributes(match, directive);
ProcessDirective(directiveName, directive);
_lineNumber += Util.LineCount(text, textPos, match.Index + match.Length);
textPos = match.Index + match.Length;
int newlineIndex = text.LastIndexOfAny(s_newlineChars, textPos-1);
_startColumn = textPos - newlineIndex;
}
if (!_fFoundMainDirective && !IgnoreParseErrors) {
throw new HttpException(
SR.GetString(SR.Missing_directive, DefaultDirectiveName));
}
// skip the directive
string remainingText = text.Substring(textPos);
// If there is something else in the file, it needs to be compiled
if (!Util.IsWhiteSpaceString(remainingText))
_sourceString = remainingText;
}
private string ProcessAttributes(Match match, IDictionary attribs) {
string ret = String.Empty;
CaptureCollection attrnames = match.Groups["attrname"].Captures;
CaptureCollection attrvalues = match.Groups["attrval"].Captures;
CaptureCollection equalsign = null;
equalsign = match.Groups["equal"].Captures;
for (int i = 0; i < attrnames.Count; i++) {
string attribName = attrnames[i].ToString();
string attribValue = attrvalues[i].ToString();
// Check if there is an equal sign.
bool fHasEqual = (equalsign[i].ToString().Length > 0);
if (attribName != null) {
// A <%@ %> block can have two formats:
// <%@ directive foo=1 bar=hello %>
// <%@ foo=1 bar=hello %>
// Check if we have the first format
if (!fHasEqual && i==0) {
ret = attribName;
continue;
}
try {
if (attribs != null)
attribs.Add(attribName, attribValue);
}
catch (ArgumentException) {
// Ignore the duplicate attributes when called from CBM
if (IgnoreParseErrors) continue;
throw new HttpException(
SR.GetString(SR.Duplicate_attr_in_tag, attribName));
}
}
}
return ret;
}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected abstract string DefaultDirectiveName { get; }
private static void ProcessCompilationParams(IDictionary directive, CompilerParameters compilParams) {
bool fDebug = false;
if (Util.GetAndRemoveBooleanAttribute(directive, "debug", ref fDebug))
compilParams.IncludeDebugInformation = fDebug;
if (compilParams.IncludeDebugInformation &&
!HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Medium)) {
throw new HttpException(SR.GetString(SR.Insufficient_trust_for_attribute, "debug"));
}
int warningLevel=0;
if (Util.GetAndRemoveNonNegativeIntegerAttribute(directive, "warninglevel", ref warningLevel)) {
compilParams.WarningLevel = warningLevel;
if (warningLevel > 0)
compilParams.TreatWarningsAsErrors = true;
}
string compilerOptions = Util.GetAndRemoveNonEmptyAttribute(
directive, "compileroptions");
if (compilerOptions != null) {
CompilationUtil.CheckCompilerOptionsAllowed(compilerOptions, false /*config*/, null, 0);
compilParams.CompilerOptions = compilerOptions;
}
}
/*
* Process a <%@ %> block
*/
internal virtual void ProcessDirective(string directiveName, IDictionary directive) {
// Empty means default
if (directiveName.Length == 0)
directiveName = DefaultDirectiveName;
// Check for the main directive
if (IsMainDirective(directiveName)) {
// Make sure the main directive was not already specified
if (_fFoundMainDirective && !IgnoreParseErrors) {
throw new HttpException(
SR.GetString(SR.Only_one_directive_allowed, DefaultDirectiveName));
}
_fFoundMainDirective = true;
// Since description is a no op, just remove it if it's there
directive.Remove("description");
// Similarily, ignore 'codebehind' attribute (ASURT 4591)
directive.Remove("codebehind");
string language = Util.GetAndRemoveNonEmptyAttribute(directive, "language");
// Get the compiler for the specified language (if any)
if (language != null) {
_compilerType = _buildProvider.GetDefaultCompilerTypeForLanguageInternal(language);
}
else {
// Get a default from config
_compilerType = _buildProvider.GetDefaultCompilerTypeInternal();
}
_typeName = Util.GetAndRemoveRequiredAttribute(directive, "class");
if (_compilerType.CompilerParameters != null)
ProcessCompilationParams(directive, _compilerType.CompilerParameters);
}
else if (StringUtil.EqualsIgnoreCase(directiveName, "assembly")) {
// Assembly directive
// Remove the attributes as we get them from the dictionary
string assemblyName = Util.GetAndRemoveNonEmptyAttribute(directive, "name");
VirtualPath src = Util.GetAndRemoveVirtualPathAttribute(directive, "src");
if (assemblyName != null && src != null && !IgnoreParseErrors) {
throw new HttpException(
SR.GetString(SR.Attributes_mutually_exclusive, "Name", "Src"));
}
if (assemblyName != null) {
AddAssemblyDependency(assemblyName);
}
// Is it a source file that needs to be compiled on the fly
else if (src != null) {
ImportSourceFile(src);
}
else if (!IgnoreParseErrors) {
throw new HttpException(SR.GetString(SR.Missing_attr, "name"));
}
}
else if (!IgnoreParseErrors) {
throw new HttpException(
SR.GetString(SR.Unknown_directive, directiveName));
}
// If there are some attributes left, fail
Util.CheckUnknownDirectiveAttributes(directiveName, directive);
}
internal virtual bool IsMainDirective(string directiveName) {
return (string.Compare(directiveName, DefaultDirectiveName,
StringComparison.OrdinalIgnoreCase) == 0);
}
/*
* Compile a source file into an assembly, and import it
*/
private void ImportSourceFile(VirtualPath virtualPath) {
// Get a full path to the source file
VirtualPath baseVirtualDir = _virtualPath.Parent;
VirtualPath fullVirtualPath = baseVirtualDir.Combine(virtualPath);
// Add the source file to the list of files we depend on
AddSourceDependency(fullVirtualPath);
//
CompilationUtil.GetCompilerInfoFromVirtualPath(fullVirtualPath);
// Compile it into an assembly
BuildResultCompiledAssembly result = (BuildResultCompiledAssembly) BuildManager.GetVPathBuildResult(
fullVirtualPath);
Assembly a = result.ResultAssembly;
// Add a dependency to the assembly
AddAssemblyDependency(a);
}
/*
* Add a file as a dependency for the DLL we're building
*/
internal void AddSourceDependency(VirtualPath fileName) {
if (_sourceDependencies == null)
_sourceDependencies = new CaseInsensitiveStringSet();
_sourceDependencies.Add(fileName.VirtualPathString);
}
private void AddAssemblyDependency(string assemblyName) {
// Load and keep track of the assembly
Assembly a = Assembly.Load(assemblyName);
AddAssemblyDependency(a);
}
private void AddAssemblyDependency(Assembly assembly) {
if (_linkedAssemblies == null)
_linkedAssemblies = new AssemblySet();
_linkedAssemblies.Add(assembly);
}
/*
* Look for a type by name in the assemblies available to this page
*/
private Type GetType(string typeName) {
Type t;
// If it contains an assembly name, just call Type.GetType (ASURT 53589)
if (Util.TypeNameContainsAssembly(typeName)) {
try {
t = Type.GetType(typeName, true);
}
catch (Exception e) {
throw new HttpParseException(null, e, _virtualPath, _sourceString, _lineNumber);
}
return t;
}
t = Util.GetTypeFromAssemblies(_referencedAssemblies, typeName, false /*ignoreCase*/);
if (t != null)
return t;
t = Util.GetTypeFromAssemblies(_linkedAssemblies, typeName, false /*ignoreCase*/);
if (t != null)
return t;
throw new HttpParseException(
SR.GetString(SR.Could_not_create_type, typeName),
null, _virtualPath, _sourceString, _lineNumber);
}
/// <internalonly/>
ICollection IAssemblyDependencyParser.AssemblyDependencies {
get {
return AssemblyDependencies;
}
}
}
/// <internalonly/>
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
internal class WebHandlerParser: SimpleWebHandlerParser {
internal WebHandlerParser(string virtualPath)
: base(null /*context*/, virtualPath, null /*physicalPath*/) {}
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected override string DefaultDirectiveName {
get { return "webhandler"; }
}
internal override void ValidateBaseType(Type t) {
// Make sure the type has the correct base class
Util.CheckAssignableType(typeof(IHttpHandler), t);
}
}
/// <internalonly/>
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
public class WebServiceParser: SimpleWebHandlerParser {
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
// Only allowed in full trust (ASURT 123890)
[SecurityPermission(SecurityAction.Demand, Unrestricted=true)]
public static Type GetCompiledType(string inputFile, HttpContext context) {
// NOTE: the inputFile parameter should be named virtualPath, but cannot be changed
// as it would be a minor breaking change! (VSWhidbey 80997).
BuildResultCompiledType result = (BuildResultCompiledType) BuildManager.GetVPathBuildResult(
context, VirtualPath.Create(inputFile));
return result.ResultType;
}
internal WebServiceParser(string virtualPath)
: base(null /*context*/, virtualPath, null /*physicalPath*/) { }
/// <devdoc>
/// <para>[To be supplied.]</para>
/// </devdoc>
protected override string DefaultDirectiveName {
get { return "webservice"; }
}
}
}