701 lines
22 KiB
C#
701 lines
22 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="HttpException.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
/*
|
|
* Exception thrown by ASP.NET managed runtime
|
|
*
|
|
* Copyright (c) 1998 Microsoft Corporation
|
|
*/
|
|
|
|
namespace System.Web {
|
|
using System.IO;
|
|
using System.Runtime.InteropServices;
|
|
using System.Runtime.Serialization;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Configuration;
|
|
using System.Diagnostics.CodeAnalysis;
|
|
using System.Security;
|
|
using System.Globalization;
|
|
using System.CodeDom.Compiler;
|
|
using System.Security.Permissions;
|
|
using System.Web.Hosting;
|
|
using System.Web.Management;
|
|
using System.Web.Util;
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Enables ASP.NET
|
|
/// to send exception information.</para>
|
|
/// </devdoc>
|
|
[Serializable]
|
|
public class HttpException : ExternalException {
|
|
private const int FACILITY_WIN32 = 7;
|
|
|
|
private int _httpCode;
|
|
private ErrorFormatter _errorFormatter;
|
|
private int _webEventCode = WebEventCodes.UndefinedEventCode;
|
|
|
|
// N.B. The last error code can be lost if we were to
|
|
// call UnsafeNativeMethods.GetLastError from this function
|
|
// and it were not yet jitted.
|
|
internal static int HResultFromLastError(int lastError) {
|
|
int hr;
|
|
|
|
if (lastError < 0) {
|
|
hr = lastError;
|
|
}
|
|
else {
|
|
hr = (int)(((uint)lastError & 0x0000FFFF) | (FACILITY_WIN32 << 16) | 0x80000000);
|
|
}
|
|
|
|
return hr;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Creates a new Exception based on the previous Exception. </para>
|
|
/// </devdoc>
|
|
public static HttpException CreateFromLastError(String message) {
|
|
return new HttpException(message, HResultFromLastError(Marshal.GetLastWin32Error()));
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Default constructor.</para>
|
|
/// </devdoc>
|
|
public HttpException() {}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>
|
|
/// Construct an exception using error message.
|
|
/// </para>
|
|
/// </devdoc>
|
|
public HttpException(String message)
|
|
|
|
: base(message) {
|
|
}
|
|
|
|
internal HttpException(String message, Exception innerException, int code)
|
|
|
|
: base(message, innerException) {
|
|
_webEventCode = code;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Construct an exception using error message and hr.</para>
|
|
/// </devdoc>
|
|
public HttpException(String message, int hr)
|
|
|
|
: base(message) {
|
|
HResult = hr;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Construct an exception using error message, HTTP code,
|
|
/// and innerException
|
|
/// .</para>
|
|
/// </devdoc>
|
|
public HttpException(String message, Exception innerException)
|
|
|
|
: base(message, innerException) {
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Construct an exception using HTTP error code, error message,
|
|
/// and innerException
|
|
/// .</para>
|
|
/// </devdoc>
|
|
public HttpException(int httpCode, String message, Exception innerException)
|
|
|
|
: base(message, innerException) {
|
|
_httpCode = httpCode;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Construct an
|
|
/// exception using HTTP error code and error message.</para>
|
|
/// </devdoc>
|
|
public HttpException(int httpCode, String message)
|
|
|
|
: base(message) {
|
|
_httpCode = httpCode;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Construct an exception
|
|
/// using HTTP error code, error message, and hr.</para>
|
|
/// </devdoc>
|
|
public HttpException(int httpCode, String message, int hr)
|
|
|
|
: base(message) {
|
|
HResult = hr;
|
|
_httpCode = httpCode;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Contructor used for derialization.</para>
|
|
/// </devdoc>
|
|
protected HttpException(SerializationInfo info, StreamingContext context)
|
|
:base(info, context) {
|
|
_httpCode = info.GetInt32("_httpCode");
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Serialize the object.</para>
|
|
/// </devdoc>
|
|
//[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter=true)]
|
|
[SuppressMessage("Microsoft.Security", "CA2110:SecureGetObjectDataOverrides", Justification = "Base class has demand")]
|
|
public override void GetObjectData(SerializationInfo info, StreamingContext context)
|
|
{
|
|
base.GetObjectData(info, context);
|
|
info.AddValue("_httpCode", _httpCode);
|
|
}
|
|
|
|
/*
|
|
* If we have an Http code (non-zero), return it. Otherwise, return
|
|
* the inner exception's code. If there isn't one, return 500.
|
|
*/
|
|
|
|
/// <devdoc>
|
|
/// <para>HTTP return code to send back to client. If there is a
|
|
/// non-zero Http code, it is returned. Otherwise, the System.HttpException.innerException
|
|
/// code is returned. If
|
|
/// there isn't an inner exception, error code 500 is returned.</para>
|
|
/// </devdoc>
|
|
public int GetHttpCode() {
|
|
return GetHttpCodeForException(this);
|
|
}
|
|
|
|
internal void SetFormatter(ErrorFormatter errorFormatter) {
|
|
_errorFormatter = errorFormatter;
|
|
}
|
|
|
|
internal static int GetHttpCodeForException(Exception e) {
|
|
|
|
if (e is HttpException) {
|
|
HttpException he = (HttpException)e;
|
|
|
|
// If the HttpException specifies an HTTP code, use it
|
|
if (he._httpCode > 0)
|
|
return he._httpCode;
|
|
}
|
|
/*
|
|
404 conversion is done in HttpAplpication.MapHttpHandler
|
|
|
|
else if (e is FileNotFoundException || e is DirectoryNotFoundException)
|
|
{
|
|
code = 404;
|
|
}
|
|
*/
|
|
else if (e is UnauthorizedAccessException) {
|
|
return 401;
|
|
}
|
|
else if (e is PathTooLongException) {
|
|
return 414;
|
|
}
|
|
|
|
// If there is an inner exception, try to get the code from it
|
|
if (e.InnerException != null)
|
|
return GetHttpCodeForException(e.InnerException);
|
|
|
|
// If all else fails, use 500
|
|
return 500;
|
|
}
|
|
|
|
/*
|
|
* Return the formatter associated with this exception
|
|
*/
|
|
internal static ErrorFormatter GetErrorFormatter(Exception e) {
|
|
Exception inner = e.InnerException;
|
|
ErrorFormatter nestedFormatter = null;
|
|
|
|
// First, see if the inner exception has a formatter
|
|
if (inner != null) {
|
|
nestedFormatter = GetErrorFormatter(inner);
|
|
if (nestedFormatter != null)
|
|
return nestedFormatter;
|
|
|
|
if (inner is ConfigurationException)
|
|
{
|
|
ConfigurationException ce = inner as ConfigurationException;
|
|
if (ce != null && ce.Filename != null)
|
|
nestedFormatter = new ConfigErrorFormatter((ConfigurationException)inner);
|
|
}
|
|
else if (inner is SecurityException)
|
|
nestedFormatter = new SecurityErrorFormatter(inner);
|
|
}
|
|
|
|
// If it does, return it rather than our own
|
|
if (nestedFormatter != null)
|
|
return nestedFormatter;
|
|
|
|
HttpException httpExc = e as HttpException;
|
|
if (httpExc != null)
|
|
return httpExc._errorFormatter;
|
|
|
|
return null;
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>[To be supplied.]</para>
|
|
/// </devdoc>
|
|
public string GetHtmlErrorMessage() {
|
|
ErrorFormatter formatter = GetErrorFormatter(this);
|
|
if (formatter == null) return null;
|
|
return formatter.GetHtmlErrorMessage();
|
|
}
|
|
|
|
public int WebEventCode {
|
|
get { return _webEventCode; }
|
|
internal set { _webEventCode = value; }
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Exception thrown when a generic error occurs.</para>
|
|
/// </devdoc>
|
|
[Serializable]
|
|
public sealed class HttpUnhandledException : HttpException {
|
|
|
|
|
|
public HttpUnhandledException() {}
|
|
|
|
|
|
public HttpUnhandledException(String message)
|
|
|
|
: base(message) {
|
|
}
|
|
|
|
|
|
public HttpUnhandledException(string message, Exception innerException)
|
|
: base(message, innerException) {
|
|
|
|
SetFormatter(new UnhandledErrorFormatter(innerException, message, null));
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
internal HttpUnhandledException(string message, string postMessage, Exception innerException)
|
|
: base(message, innerException) {
|
|
|
|
SetFormatter(new UnhandledErrorFormatter(innerException, message, postMessage));
|
|
}
|
|
|
|
private HttpUnhandledException(SerializationInfo info, StreamingContext context)
|
|
:base(info, context) {
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Exception thrown when a compilation error occurs.</para>
|
|
/// </devdoc>
|
|
[Serializable]
|
|
public sealed class HttpCompileException : HttpException {
|
|
|
|
private CompilerResults _results;
|
|
private string _sourceCode;
|
|
|
|
|
|
public HttpCompileException() {
|
|
}
|
|
|
|
|
|
public HttpCompileException(string message) : base(message) {
|
|
}
|
|
|
|
|
|
public HttpCompileException(String message, Exception innerException) : base(message, innerException) {
|
|
}
|
|
|
|
|
|
public HttpCompileException(CompilerResults results, string sourceCode) {
|
|
_results = results;
|
|
_sourceCode = sourceCode;
|
|
|
|
SetFormatter(new DynamicCompileErrorFormatter(this));
|
|
}
|
|
|
|
private HttpCompileException(SerializationInfo info, StreamingContext context)
|
|
:base(info, context) {
|
|
_results = (CompilerResults) info.GetValue("_results", typeof(CompilerResults));
|
|
_sourceCode = info.GetString("_sourceCode");
|
|
}
|
|
|
|
// Determines whether the compile exception should be cached
|
|
private bool _dontCache;
|
|
internal bool DontCache {
|
|
get { return _dontCache; }
|
|
set { _dontCache = value; }
|
|
}
|
|
|
|
// The virtualpath depdencies for current buildresult.
|
|
private ICollection _virtualPathDependencies;
|
|
internal ICollection VirtualPathDependencies {
|
|
get { return _virtualPathDependencies; }
|
|
set { _virtualPathDependencies = value; }
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Serialize the object.</para>
|
|
/// </devdoc>
|
|
[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter=true)]
|
|
public override void GetObjectData(SerializationInfo info, StreamingContext context)
|
|
{
|
|
base.GetObjectData(info, context);
|
|
info.AddValue("_results", _results);
|
|
info.AddValue("_sourceCode", _sourceCode);
|
|
}
|
|
|
|
private const string compileErrorFormat = "{0}({1}): error {2}: {3}";
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> The first compilation error.</para>
|
|
/// </devdoc>
|
|
public override string Message {
|
|
get {
|
|
// Return the first compile error as the exception message
|
|
CompilerError e = FirstCompileError;
|
|
|
|
if (e == null)
|
|
return base.Message;
|
|
|
|
string message = String.Format(CultureInfo.CurrentCulture, compileErrorFormat,
|
|
e.FileName, e.Line, e.ErrorNumber, e.ErrorText);
|
|
|
|
return message;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> The CompilerResults object describing the compile error.</para>
|
|
/// </devdoc>
|
|
public CompilerResults Results {
|
|
[AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.High)]
|
|
get {
|
|
return _results;
|
|
}
|
|
}
|
|
|
|
internal CompilerResults ResultsWithoutDemand {
|
|
get {
|
|
return _results;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para> The source code that was compiled.</para>
|
|
/// </devdoc>
|
|
public string SourceCode {
|
|
[AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.High)]
|
|
get {
|
|
return _sourceCode;
|
|
}
|
|
}
|
|
|
|
internal string SourceCodeWithoutDemand {
|
|
get {
|
|
return _sourceCode;
|
|
}
|
|
}
|
|
|
|
// Return the first compile error, or null if there isn't one
|
|
internal CompilerError FirstCompileError {
|
|
get {
|
|
if (_results == null || !_results.Errors.HasErrors)
|
|
return null;
|
|
|
|
CompilerError e = null;
|
|
|
|
foreach (CompilerError error in _results.Errors) {
|
|
|
|
// Ignore warnings
|
|
if (error.IsWarning) continue;
|
|
|
|
// If we found an error that's not in the generated code, use it
|
|
if (HttpRuntime.CodegenDirInternal != null && error.FileName != null &&
|
|
!StringUtil.StringStartsWith(error.FileName, HttpRuntime.CodegenDirInternal)) {
|
|
e = error;
|
|
break;
|
|
}
|
|
|
|
// The current error is in the generated code. Keep track of
|
|
// it if it's the first one, but keep on looking in case we find another
|
|
// one that's not in the generated code (ASURT 62600)
|
|
if (e == null)
|
|
e = error;
|
|
}
|
|
|
|
return e;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Exception thrown when a parse error occurs.</para>
|
|
/// </devdoc>
|
|
[Serializable]
|
|
public sealed class HttpParseException : HttpException {
|
|
|
|
private VirtualPath _virtualPath;
|
|
private int _line;
|
|
private ParserErrorCollection _parserErrors;
|
|
|
|
|
|
public HttpParseException() {
|
|
}
|
|
|
|
|
|
public HttpParseException(string message) : base(message) {
|
|
}
|
|
|
|
|
|
public HttpParseException(String message, Exception innerException) : base(message, innerException) {
|
|
}
|
|
|
|
|
|
public HttpParseException(string message, Exception innerException, string virtualPath,
|
|
string sourceCode, int line) : this(message, innerException,
|
|
System.Web.VirtualPath.CreateAllowNull(virtualPath), sourceCode, line) {}
|
|
|
|
internal HttpParseException(string message, Exception innerException, VirtualPath virtualPath,
|
|
string sourceCode, int line)
|
|
: base(message, innerException) {
|
|
|
|
_virtualPath = virtualPath;
|
|
_line = line;
|
|
|
|
string formatterMessage;
|
|
if (innerException != null)
|
|
formatterMessage = innerException.Message;
|
|
else
|
|
formatterMessage = message;
|
|
|
|
SetFormatter(new ParseErrorFormatter(this, System.Web.VirtualPath.GetVirtualPathString(virtualPath), sourceCode,
|
|
line, formatterMessage));
|
|
}
|
|
|
|
private HttpParseException(SerializationInfo info, StreamingContext context)
|
|
:base(info, context) {
|
|
_virtualPath = (VirtualPath)info.GetValue("_virtualPath", typeof(VirtualPath));
|
|
_line = info.GetInt32("_line");
|
|
_parserErrors = (ParserErrorCollection)info.GetValue("_parserErrors", typeof(ParserErrorCollection));
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para>Serialize the object.</para>
|
|
/// </devdoc>
|
|
[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter=true)]
|
|
public override void GetObjectData(SerializationInfo info, StreamingContext context)
|
|
{
|
|
base.GetObjectData(info, context);
|
|
info.AddValue("_virtualPath", _virtualPath);
|
|
info.AddValue("_line", _line);
|
|
info.AddValue("_parserErrors", _parserErrors);
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> The physical path to source file that has the error.</para>
|
|
/// </devdoc>
|
|
public string FileName {
|
|
get {
|
|
string physicalPath = _virtualPath.MapPathInternal();
|
|
|
|
if (physicalPath == null)
|
|
return null;
|
|
|
|
// Demand path discovery before returning the path (ASURT 123798)
|
|
InternalSecurityPermissions.PathDiscovery(physicalPath).Demand();
|
|
return physicalPath;
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> The virtual path to source file that has the error.</para>
|
|
/// </devdoc>
|
|
public string VirtualPath {
|
|
get {
|
|
return System.Web.VirtualPath.GetVirtualPathString(_virtualPath);
|
|
}
|
|
}
|
|
|
|
internal VirtualPath VirtualPathObject {
|
|
get {
|
|
return _virtualPath;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// <para> The CompilerResults object describing the compile error.</para>
|
|
/// </devdoc>
|
|
public int Line {
|
|
get { return _line;}
|
|
}
|
|
|
|
// The set of parser errors
|
|
public ParserErrorCollection ParserErrors {
|
|
get {
|
|
if (_parserErrors == null) {
|
|
_parserErrors = new ParserErrorCollection();
|
|
ParserError thisError = new ParserError(Message, _virtualPath, _line);
|
|
_parserErrors.Add(thisError);
|
|
}
|
|
|
|
return _parserErrors;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
/// <devdoc>
|
|
/// <para> Exception thrown when a potentially unsafe input string is detected (ASURT 122278)</para>
|
|
/// </devdoc>
|
|
[Serializable]
|
|
public sealed class HttpRequestValidationException : HttpException {
|
|
|
|
|
|
public HttpRequestValidationException() {
|
|
}
|
|
|
|
|
|
public HttpRequestValidationException(string message) : base(message) {
|
|
|
|
SetFormatter(new UnhandledErrorFormatter(
|
|
this, SR.GetString(SR.Dangerous_input_detected_descr), null));
|
|
}
|
|
|
|
|
|
public HttpRequestValidationException(String message, Exception innerException) : base(message, innerException) {
|
|
}
|
|
|
|
private HttpRequestValidationException(SerializationInfo info, StreamingContext context)
|
|
:base(info, context) {
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public sealed class ParserError {
|
|
private int _line;
|
|
private VirtualPath _virtualPath;
|
|
private string _errorText;
|
|
private Exception _exception;
|
|
|
|
public ParserError() {
|
|
}
|
|
|
|
public ParserError(string errorText, string virtualPath, int line)
|
|
: this(errorText, System.Web.VirtualPath.CreateAllowNull(virtualPath), line) {
|
|
}
|
|
|
|
internal ParserError(string errorText, VirtualPath virtualPath, int line) {
|
|
_virtualPath = virtualPath;
|
|
_line = line;
|
|
_errorText = errorText;
|
|
}
|
|
|
|
// The original exception that introduces the Parser Error
|
|
internal Exception Exception {
|
|
get { return _exception; }
|
|
set { _exception = value; }
|
|
}
|
|
|
|
// The virtualPath where the parser error occurs.
|
|
public string VirtualPath {
|
|
get { return System.Web.VirtualPath.GetVirtualPathString(_virtualPath); }
|
|
set { _virtualPath = System.Web.VirtualPath.Create(value); }
|
|
}
|
|
|
|
// The description error text of the error.
|
|
public string ErrorText {
|
|
get { return _errorText; }
|
|
set { _errorText = value; }
|
|
}
|
|
|
|
// The line where the parser error occurs.
|
|
public int Line {
|
|
get { return _line; }
|
|
set { _line = value; }
|
|
}
|
|
}
|
|
|
|
[Serializable]
|
|
public sealed class ParserErrorCollection : CollectionBase {
|
|
public ParserErrorCollection() {
|
|
}
|
|
|
|
public ParserErrorCollection(ParserError[] value) {
|
|
this.AddRange(value);
|
|
}
|
|
|
|
public ParserError this[int index] {
|
|
get { return ((ParserError)List[index]); }
|
|
set { List[index] = value; }
|
|
}
|
|
|
|
public int Add(ParserError value) {
|
|
return List.Add(value);
|
|
}
|
|
|
|
public void AddRange(ParserError[] value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
for (int i = 0; i < value.Length; i++) {
|
|
this.Add(value[i]);
|
|
}
|
|
}
|
|
|
|
public void AddRange(ParserErrorCollection value) {
|
|
if (value == null) {
|
|
throw new ArgumentNullException("value");
|
|
}
|
|
|
|
foreach(ParserError parserError in value) {
|
|
this.Add(parserError);
|
|
}
|
|
}
|
|
|
|
public bool Contains(ParserError value) {
|
|
return List.Contains(value);
|
|
}
|
|
|
|
public void CopyTo(ParserError[] array, int index) {
|
|
List.CopyTo(array, index);
|
|
}
|
|
|
|
public int IndexOf(ParserError value) {
|
|
return List.IndexOf(value);
|
|
}
|
|
|
|
public void Insert(int index, ParserError value) {
|
|
List.Insert(index, value);
|
|
}
|
|
|
|
public void Remove(ParserError value) {
|
|
List.Remove(value);
|
|
}
|
|
}
|
|
}
|