Code:
/ FX-1434 / FX-1434 / 1.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / HttpException.cs / 2 / HttpException.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
/*
* 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.Security;
using System.Globalization;
using System.CodeDom.Compiler;
using System.Security.Permissions;
using System.Web.Hosting;
using System.Web.Management;
using System.Web.Util;
///
/// Enables ASP.NET
/// to send exception information.
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[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;
}
///
/// Creates a new Exception based on the previous Exception.
///
public static HttpException CreateFromLastError(String message) {
return new HttpException(message, HResultFromLastError(Marshal.GetLastWin32Error()));
}
///
/// Default constructor.
///
public HttpException() {}
///
///
/// Construct an exception using error message.
///
///
public HttpException(String message)
: base(message) {
}
internal HttpException(String message, Exception innerException, int code)
: base(message, innerException) {
_webEventCode = code;
}
///
/// Construct an exception using error message and hr.
///
public HttpException(String message, int hr)
: base(message) {
HResult = hr;
}
///
/// Construct an exception using error message, HTTP code,
/// and innerException
/// .
///
public HttpException(String message, Exception innerException)
: base(message, innerException) {
}
///
/// Construct an exception using HTTP error code, error message,
/// and innerException
/// .
///
public HttpException(int httpCode, String message, Exception innerException)
: base(message, innerException) {
_httpCode = httpCode;
}
///
/// Construct an
/// exception using HTTP error code and error message.
///
public HttpException(int httpCode, String message)
: base(message) {
_httpCode = httpCode;
}
///
/// Construct an exception
/// using HTTP error code, error message, and hr.
///
public HttpException(int httpCode, String message, int hr)
: base(message) {
HResult = hr;
_httpCode = httpCode;
}
///
/// Contructor used for derialization.
///
protected HttpException(SerializationInfo info, StreamingContext context)
:base(info, context) {
_httpCode = info.GetInt32("_httpCode");
}
///
/// Serialize the object.
///
[SecurityPermissionAttribute(SecurityAction.Demand, SerializationFormatter=true)]
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.
*/
///
/// 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.
///
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;
}
///
/// [To be supplied.]
///
public string GetHtmlErrorMessage() {
ErrorFormatter formatter = GetErrorFormatter(this);
if (formatter == null) return null;
return formatter.GetHtmlErrorMessage();
}
internal int WebEventCode {
get { return _webEventCode; }
set { _webEventCode = value; }
}
}
///
/// Exception thrown when a generic error occurs.
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[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));
}
///
/// Exception thrown when a compilation error occurs.
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[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; }
}
///
/// Serialize the object.
///
[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}";
///
/// The first compilation error.
///
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;
}
}
///
/// The CompilerResults object describing the compile error.
///
public CompilerResults Results {
[AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.High)]
get {
return _results;
}
}
///
/// The source code that was compiled.
///
public string SourceCode {
[AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.High)]
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;
}
}
}
///
/// Exception thrown when a parse error occurs.
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[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));
}
///
/// Serialize the object.
///
[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);
}
///
/// The physical path to source file that has the error.
///
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;
}
}
///
/// The virtual path to source file that has the error.
///
public string VirtualPath {
get {
return System.Web.VirtualPath.GetVirtualPathString(_virtualPath);
}
}
internal VirtualPath VirtualPathObject {
get {
return _virtualPath;
}
}
///
/// The CompilerResults object describing the compile error.
///
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;
}
}
}
///
/// Exception thrown when a potentially unsafe input string is detected (ASURT 122278)
///
[AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
[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]
[AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
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); }
}
#if UNUSED
// The virtualPath where the parser error occurs.
internal VirtualPath VirtualPathObject {
get { return _virtualPath; }
set { _virtualPath = value; }
}
#endif
// 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]
[AspNetHostingPermission(SecurityAction.LinkDemand, Level = AspNetHostingPermissionLevel.Minimal)]
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);
}
}
}
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ImmComposition.cs
- ProgressBarHighlightConverter.cs
- StatusBarItemAutomationPeer.cs
- SliderAutomationPeer.cs
- DoubleAnimationUsingKeyFrames.cs
- ExtenderControl.cs
- SignatureConfirmationElement.cs
- PackageRelationshipSelector.cs
- IntegerFacetDescriptionElement.cs
- InvalidEnumArgumentException.cs
- AlignmentXValidation.cs
- WindowsToolbarItemAsMenuItem.cs
- ChangeToolStripParentVerb.cs
- LinkArea.cs
- EventProperty.cs
- DrawingDrawingContext.cs
- MSHTMLHost.cs
- IsolatedStorage.cs
- CodeNamespaceCollection.cs
- Debugger.cs
- TextEncodedRawTextWriter.cs
- UnmanagedBitmapWrapper.cs
- WebMessageEncodingBindingElement.cs
- MeasureItemEvent.cs
- SizeAnimation.cs
- WebBrowserDocumentCompletedEventHandler.cs
- BamlRecordReader.cs
- SerializableAttribute.cs
- AtomEntry.cs
- DockAndAnchorLayout.cs
- DefaultTextStoreTextComposition.cs
- SerializerDescriptor.cs
- SelectedGridItemChangedEvent.cs
- SecurityState.cs
- GenericFlowSwitchHelper.cs
- BitmapEffectrendercontext.cs
- CqlParserHelpers.cs
- InvalidAsynchronousStateException.cs
- ExpressionBuilder.cs
- MatrixTransform.cs
- BufferModesCollection.cs
- PageBreakRecord.cs
- UserControlCodeDomTreeGenerator.cs
- WebSysDescriptionAttribute.cs
- TrackingStringDictionary.cs
- HtmlInputButton.cs
- LinqDataSourceDeleteEventArgs.cs
- ISessionStateStore.cs
- EntitySqlQueryCacheKey.cs
- BaseConfigurationRecord.cs
- HostExecutionContextManager.cs
- AccessDataSourceView.cs
- HtmlTableCellCollection.cs
- xmlsaver.cs
- FormViewInsertedEventArgs.cs
- OneWayBindingElement.cs
- securitycriticaldataformultiplegetandset.cs
- SmtpSection.cs
- ProviderMetadata.cs
- TokenBasedSet.cs
- Control.cs
- OdbcException.cs
- SoundPlayerAction.cs
- MobileListItem.cs
- CommonDialog.cs
- DataGridViewHitTestInfo.cs
- PeerHopCountAttribute.cs
- StructuredType.cs
- CultureTable.cs
- ToolBarDesigner.cs
- SafeNativeMethods.cs
- ScriptResourceHandler.cs
- CodeAssignStatement.cs
- SplashScreen.cs
- WebReferencesBuildProvider.cs
- TextEditorThreadLocalStore.cs
- ExpressionBinding.cs
- KeyInfo.cs
- ToolTipAutomationPeer.cs
- OleCmdHelper.cs
- DataGridAutoFormatDialog.cs
- Semaphore.cs
- CryptoApi.cs
- HttpTransportSecurity.cs
- AsyncOperation.cs
- FileIOPermission.cs
- AsyncOperation.cs
- DataGridViewCellStyle.cs
- PathSegment.cs
- QueueProcessor.cs
- Serializer.cs
- RecognizedPhrase.cs
- JoinElimination.cs
- XmlNamespaceManager.cs
- TypeConverter.cs
- arabicshape.cs
- TypeBuilderInstantiation.cs
- QueryStringHandler.cs
- compensatingcollection.cs
- SchemaElementDecl.cs