562 lines
18 KiB
C#
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"; }
|
|
}
|
|
}
|
|
|
|
}
|