//
// System.Web.UI.SimpleWebHandlerParser
//
// Authors:
// Gonzalo Paniagua Javier (gonzalo@ximian.com)
//
// (C) 2002,2003 Ximian, Inc (http://www.ximian.com)
// Copyright (C) 2005-2010 Novell, Inc (http://www.novell.com)
//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
//
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
using System.CodeDom.Compiler;
using System.Collections;
using System.Globalization;
using System.IO;
using System.Reflection;
using System.Security.Permissions;
using System.Text;
using System.Web.Compilation;
using System.Web.Configuration;
using System.Web.Util;
namespace System.Web.UI{
// CAS
[AspNetHostingPermission (SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission (SecurityAction.InheritanceDemand, Level = AspNetHostingPermissionLevel.Minimal)]
public abstract class SimpleWebHandlerParser
{
HttpContext context;
string vPath;
string physPath;
string className;
bool debug;
string language;
string program;
bool gotDefault;
ArrayList assemblies;
ArrayList dependencies;
Hashtable anames;
string baseDir;
string baseVDir;
TextReader reader;
int appAssemblyIndex = -1;
Type cachedType;
protected SimpleWebHandlerParser (HttpContext context, string virtualPath, string physicalPath)
: this (context, virtualPath, physicalPath, null)
{}
internal SimpleWebHandlerParser (HttpContext context, string virtualPath, string physicalPath, TextReader reader)
{
this.reader = reader;
cachedType = CachingCompiler.GetTypeFromCache (physicalPath);
if (cachedType != null)
return; // We don't need anything else.
// context is obsolete in 2.0+ - MSDN recommends passing null, so we need to
// take that into account
if (context != null)
this.context = context;
else
this.context = HttpContext.Current;
this.vPath = virtualPath;
AddDependency (virtualPath);
// physicalPath is obsolete in 2.0+ - same note what for context applies here
if (physicalPath != null && physicalPath.Length > 0)
this.physPath = physicalPath;
else {
HttpRequest req = this.context != null ? context.Request : null;
if (req != null)
this.physPath = req.MapPath (virtualPath);
}
assemblies = new ArrayList ();
string location = Context.ApplicationInstance.AssemblyLocation;
if (location != typeof (TemplateParser).Assembly.Location)
appAssemblyIndex = assemblies.Add (location);
bool addAssembliesInBin = false;
foreach (AssemblyInfo info in CompilationConfig.Assemblies) {
if (info.Assembly == "*")
addAssembliesInBin = true;
else
AddAssemblyByName (info.Assembly, null);
}
if (addAssembliesInBin)
AddAssembliesInBin ();
language = CompilationConfig.DefaultLanguage;
GetDirectivesAndContent ();
}
protected Type GetCompiledTypeFromCache ()
{
return cachedType;
}
void GetDirectivesAndContent ()
{
string line;
bool directiveFound = false;
bool inDirective = false;
StringBuilder directive = null;
StringBuilder content = new StringBuilder ();
int idxStart, idxEnd, length;
StreamReader sr;
if (reader != null)
sr = reader as StreamReader;
else
sr = new StreamReader (File.OpenRead (physPath), WebEncoding.FileEncoding);
using (sr) {
while ((line = sr.ReadLine ()) != null && cachedType == null) {
length = line.Length;
if (length == 0) {
content.Append ("\n");
continue;
}
idxStart = line.IndexOf ("<%");
if (idxStart > -1) {
idxEnd = line.IndexOf ("%>");
if (idxStart > 0)
content.Append (line.Substring (0, idxStart));
if (directive == null)
directive = new StringBuilder ();
else
directive.Length = 0;
if (idxEnd > -1) {
directiveFound = true;
inDirective = false;
directive.Append (line.Substring (idxStart, idxEnd - idxStart + 2));
if (idxEnd < length - 2)
content.Append (line.Substring (idxEnd + 2, length - idxEnd - 2));
} else {
inDirective = true;
directiveFound = false;
directive.Append (line.Substring (idxStart));
continue;
}
}
if (inDirective) {
int idx = line.IndexOf ("%>");
if (idx > -1) {
directive.Append (line.Substring (0, idx + 2));
if (idx < length)
content.Append (line.Substring (idx + 2) + "\n");
inDirective = false;
directiveFound = true;
} else {
directive.Append (line);
continue;
}
}
if (directiveFound) {
ParseDirective (directive.ToString ());
directiveFound = false;
if (gotDefault) {
cachedType = CachingCompiler.GetTypeFromCache (physPath);
if (cachedType != null)
break;
}
continue;
}
content.Append (line + "\n");
}
directive = null;
}
if (!gotDefault)
throw new ParseException (null, "No @" + DefaultDirectiveName +
" directive found");
if (cachedType == null)
this.program = content.ToString ();
}
void TagParsed (ILocation location, System.Web.Compilation.TagType tagtype, string tagid, TagAttributes attributes)
{
if (tagtype != System.Web.Compilation.TagType.Directive)
throw new ParseException (location, "Unexpected tag");
if (tagid == null || tagid.Length == 0 || String.Compare (tagid, DefaultDirectiveName, true, Helpers.InvariantCulture) == 0) {
AddDefaultDirective (location, attributes);
} else if (String.Compare (tagid, "Assembly", true, Helpers.InvariantCulture) == 0) {
AddAssemblyDirective (location, attributes);
} else {
throw new ParseException (location, "Unexpected directive: " + tagid);
}
}
void TextParsed (ILocation location, string text)
{
if (text.Trim () != "")
throw new ParseException (location, "Text not allowed here");
}
void ParseError (ILocation location, string message)
{
throw new ParseException (location, message);
}
static string GetAndRemove (IDictionary table, string key)
{
string o = table [key] as string;
table.Remove (key);
return o;
}
void ParseDirective (string line)
{
AspParser parser;
using (StringReader input = new StringReader (line)) {
parser = new AspParser (physPath, input);
}
parser.Error += new ParseErrorHandler (ParseError);
parser.TagParsed += new TagParsedHandler (TagParsed);
parser.TextParsed += new TextParsedHandler (TextParsed);
parser.Parse ();
}
internal virtual void AddDefaultDirective (ILocation location, TagAttributes attrs)
{
CompilationSection compConfig;
compConfig = CompilationConfig;
if (gotDefault)
throw new ParseException (location, "duplicate " + DefaultDirectiveName + " directive");
gotDefault = true;
IDictionary attributes = attrs.GetDictionary (null);
className = GetAndRemove (attributes, "class");
if (className == null)
throw new ParseException (null, "No Class attribute found.");
string d = GetAndRemove (attributes, "debug");
if (d != null) {
debug = (String.Compare (d, "true", true, Helpers.InvariantCulture) == 0);
if (debug == false && String.Compare (d, "false", true, Helpers.InvariantCulture) != 0)
throw new ParseException (null, "Invalid value for Debug attribute");
} else
debug = compConfig.Debug;
language = GetAndRemove (attributes, "language");
if (language == null)
language = compConfig.DefaultLanguage;
GetAndRemove (attributes, "codebehind");
if (attributes.Count > 0)
throw new ParseException (location, "Unrecognized attribute in " +
DefaultDirectiveName + " directive");
}
internal virtual void AddAssemblyDirective (ILocation location, TagAttributes attrs)
{
IDictionary tbl = attrs.GetDictionary (null);
string name = GetAndRemove (tbl, "Name");
string src = GetAndRemove (tbl, "Src");
if (name == null && src == null)
throw new ParseException (location, "You gotta specify Src or Name");
if (name != null && src != null)
throw new ParseException (location, "Src and Name cannot be used together");
if (name != null) {
AddAssemblyByName (name, location);
} else {
GetAssemblyFromSource (src, location);
}
if (tbl.Count > 0)
throw new ParseException (location, "Unrecognized attribute in Assembly directive");
}
internal virtual void AddAssembly (Assembly assembly, bool fullPath)
{
if (assembly == null)
throw new ArgumentNullException ("assembly");
if (anames == null)
anames = new Hashtable ();
string name = assembly.GetName ().Name;
string loc = assembly.Location;
if (fullPath) {
if (!assemblies.Contains (loc)) {
assemblies.Add (loc);
}
anames [name] = loc;
anames [loc] = assembly;
} else {
if (!assemblies.Contains (name)) {
assemblies.Add (name);
}
anames [name] = assembly;
}
}
internal virtual Assembly AddAssemblyByName (string name, ILocation location)
{
if (anames == null)
anames = new Hashtable ();
if (anames.Contains (name)) {
object o = anames [name];
if (o is string)
o = anames [o];
return (Assembly) o;
}
Assembly assembly = LoadAssemblyFromBin (name);
if (assembly != null) {
AddAssembly (assembly, true);
return assembly;
}
Exception ex = null;
try {
assembly = Assembly.LoadWithPartialName (name);
} catch (Exception e) {
ex = e;
assembly = null;
}
if (assembly == null)
throw new ParseException (location, String.Format ("Assembly '{0}' not found", name), ex);
AddAssembly (assembly, true);
return assembly;
}
void AddAssembliesInBin ()
{
Exception ex;
foreach (string s in HttpApplication.BinDirectoryAssemblies) {
ex = null;
try {
Assembly assembly = Assembly.LoadFrom (s);
AddAssembly (assembly, true);
} catch (FileLoadException e) {
ex = e;
// ignore
} catch (BadImageFormatException e) {
ex = e;
// ignore
} catch (Exception e) {
throw new Exception ("Error while loading " + s, e);
}
if (ex != null && RuntimeHelpers.DebuggingEnabled) {
Console.WriteLine ("**** DEBUG MODE *****");
Console.WriteLine ("Bad assembly found in bin/. Exception (ignored):");
Console.WriteLine (ex);
}
}
}
Assembly LoadAssemblyFromBin (string name)
{
Assembly assembly = null;
foreach (string dll in HttpApplication.BinDirectoryAssemblies) {
string fn = Path.GetFileName (dll);
fn = Path.ChangeExtension (fn, null);
if (fn != name)
continue;
assembly = Assembly.LoadFrom (dll);
return assembly;
}
return null;
}
Assembly GetAssemblyFromSource (string vpath, ILocation location)
{
vpath = UrlUtils.Combine (BaseVirtualDir, vpath);
string realPath = context.Request.MapPath (vpath);
if (!File.Exists (realPath))
throw new ParseException (location, "File " + vpath + " not found");
AddDependency (vpath);
CompilerResults result = CachingCompiler.Compile (language, realPath, realPath, assemblies);
if (result.NativeCompilerReturnValue != 0) {
using (StreamReader sr = new StreamReader (realPath)) {
throw new CompilationException (realPath, result.Errors, sr.ReadToEnd ());
}
}
AddAssembly (result.CompiledAssembly, true);
return result.CompiledAssembly;
}
internal Type GetTypeFromBin (string tname)
{
if (tname == null || tname.Length == 0)
throw new ArgumentNullException ("tname");
Type result = null;
string typeName;
string assemblyName;
int comma = tname.IndexOf (',');
if (comma != -1) {
typeName = tname.Substring (0, comma).Trim ();
assemblyName = tname.Substring (comma + 1).Trim ();
} else {
typeName = tname;
assemblyName = null;
}
Type type = null;
Assembly assembly = null;
if (assemblyName != null) {
assembly = Assembly.Load (assemblyName);
if (assembly != null)
type = assembly.GetType (typeName, false);
if (type != null)
return type;
}
IList toplevelAssemblies = BuildManager.TopLevelAssemblies;
if (toplevelAssemblies != null && toplevelAssemblies.Count > 0) {
foreach (Assembly asm in toplevelAssemblies) {
type = asm.GetType (typeName, false);
if (type != null) {
if (result != null)
throw new HttpException (String.Format ("Type {0} is not unique.", typeName));
result = type;
}
}
}
foreach (string dll in HttpApplication.BinDirectoryAssemblies) {
try {
assembly = Assembly.LoadFrom (dll);
} catch (FileLoadException) {
// ignore
continue;
} catch (BadImageFormatException) {
// ignore
continue;
}
type = assembly.GetType (typeName, false);
if (type != null) {
if (result != null)
throw new HttpException (String.Format ("Type {0} is not unique.", typeName));
result = type;
}
}
if (result == null)
throw new HttpException (String.Format ("Type {0} not found.", typeName));
return result;
}
internal virtual void AddDependency (string filename)
{
if (dependencies == null)
dependencies = new ArrayList ();
if (!dependencies.Contains (filename))
dependencies.Add (filename);
}
// Properties
protected abstract string DefaultDirectiveName { get; }
internal HttpContext Context {
get { return context; }
}
internal string VirtualPath {
get { return vPath; }
}
internal string PhysicalPath {
get { return physPath; }
}
internal string ClassName {
get { return className; }
}
internal bool Debug {
get { return debug; }
}
internal string Language {
get { return language; }
}
internal string Program {
get {
if (program != null)
return program;
return String.Empty;
}
}
internal ArrayList Assemblies {
get {
if (appAssemblyIndex != -1) {
object o = assemblies [appAssemblyIndex];
assemblies.RemoveAt (appAssemblyIndex);
assemblies.Add (o);
appAssemblyIndex = -1;
}
return assemblies;
}
}
internal ArrayList Dependencies {
get { return dependencies; }
}
internal string BaseDir {
get {
if (baseDir == null)
baseDir = context.Request.MapPath (BaseVirtualDir);
return baseDir;
}
}
internal virtual string BaseVirtualDir {
get {
if (baseVDir == null)
baseVDir = UrlUtils.GetDirectory (context.Request.FilePath);
return baseVDir;
}
}
CompilationSection CompilationConfig {
get {
string vp = VirtualPath;
if (String.IsNullOrEmpty (vp))
return WebConfigurationManager.GetWebApplicationSection ("system.web/compilation") as CompilationSection;
else
return WebConfigurationManager.GetSection ("system.web/compilation", vp) as CompilationSection;
}
}
internal TextReader Reader {
get { return reader; }
set { reader = value; }
}
}
}
|