mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
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
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);
|
|
}
|
|
}
|
|
}
|