e79aa3c0ed
Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4
253 lines
8.8 KiB
C#
253 lines
8.8 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="CustomErrorsSection.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Configuration {
|
|
using System;
|
|
using System.Xml;
|
|
using System.Configuration;
|
|
using System.Collections.Specialized;
|
|
using System.Collections;
|
|
using System.IO;
|
|
using System.Text;
|
|
using System.Globalization;
|
|
using System.Web.Util;
|
|
using System.Web.Configuration;
|
|
using System.Security.Permissions;
|
|
|
|
/* From Machine.Config
|
|
<!--
|
|
customErrors Attributes:
|
|
mode="[On|Off|RemoteOnly]"
|
|
On: Always display custom errors
|
|
Off: Always display ASP.NET error pages
|
|
RemoteOnly: Display custom errors to remote clients and ASP.NET errors to localhost
|
|
redirectMode="[ResponseRedirect|ResponseRewrite]"
|
|
ResponseRedirect: Use redirection to display the custom error page, the URL changes
|
|
ResponseRewrite: Send the custom error page without changing the URL
|
|
defaultRedirect="url" - Url to redirect client to when an error occurs
|
|
-->
|
|
<customErrors mode="RemoteOnly" />
|
|
*/
|
|
public sealed class CustomErrorsSection : ConfigurationSection {
|
|
private static ConfigurationPropertyCollection _properties;
|
|
|
|
private static readonly ConfigurationProperty _propAllowNestedErrors =
|
|
new ConfigurationProperty("allowNestedErrors",
|
|
typeof(bool),
|
|
false /* defaultValue */,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propDefaultRedirect =
|
|
new ConfigurationProperty("defaultRedirect",
|
|
typeof(string),
|
|
null,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propRedirectMode =
|
|
new ConfigurationProperty("redirectMode",
|
|
typeof(CustomErrorsRedirectMode),
|
|
CustomErrorsRedirectMode.ResponseRedirect,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propMode =
|
|
new ConfigurationProperty("mode",
|
|
typeof(CustomErrorsMode),
|
|
CustomErrorsMode.RemoteOnly,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propErrors =
|
|
new ConfigurationProperty(null,
|
|
typeof(CustomErrorCollection),
|
|
null,
|
|
ConfigurationPropertyOptions.IsDefaultCollection);
|
|
|
|
private string basepath = null;
|
|
private string _DefaultAbsolutePath = null;
|
|
private static CustomErrorsSection _default = null;
|
|
|
|
static CustomErrorsSection() {
|
|
// Property initialization
|
|
_properties = new ConfigurationPropertyCollection();
|
|
_properties.Add(_propAllowNestedErrors);
|
|
_properties.Add(_propDefaultRedirect);
|
|
_properties.Add(_propRedirectMode);
|
|
_properties.Add(_propMode);
|
|
_properties.Add(_propErrors);
|
|
}
|
|
|
|
public CustomErrorsSection() {
|
|
}
|
|
|
|
protected override ConfigurationPropertyCollection Properties {
|
|
get {
|
|
return _properties;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("allowNestedErrors", DefaultValue = false)]
|
|
public bool AllowNestedErrors {
|
|
get {
|
|
return (bool)base[_propAllowNestedErrors];
|
|
}
|
|
set {
|
|
base[_propAllowNestedErrors] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("defaultRedirect")]
|
|
public string DefaultRedirect {
|
|
get {
|
|
return (string)base[_propDefaultRedirect];
|
|
}
|
|
set {
|
|
base[_propDefaultRedirect] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("redirectMode", DefaultValue = CustomErrorsRedirectMode.ResponseRedirect)]
|
|
public CustomErrorsRedirectMode RedirectMode {
|
|
get {
|
|
return (CustomErrorsRedirectMode)base[_propRedirectMode];
|
|
}
|
|
set {
|
|
base[_propRedirectMode] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("mode", DefaultValue = CustomErrorsMode.RemoteOnly)]
|
|
public CustomErrorsMode Mode {
|
|
get {
|
|
return (CustomErrorsMode)base[_propMode];
|
|
}
|
|
set {
|
|
base[_propMode] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("", IsDefaultCollection = true)]
|
|
public CustomErrorCollection Errors {
|
|
get {
|
|
return (CustomErrorCollection)base[_propErrors];
|
|
}
|
|
}
|
|
|
|
internal String DefaultAbsolutePath {
|
|
get {
|
|
if (_DefaultAbsolutePath == null) {
|
|
_DefaultAbsolutePath = GetAbsoluteRedirect(DefaultRedirect, basepath);
|
|
}
|
|
|
|
return _DefaultAbsolutePath;
|
|
}
|
|
}
|
|
|
|
internal String GetRedirectString(int code) {
|
|
String r = null;
|
|
|
|
if (Errors != null) {
|
|
CustomError ce = Errors[(string)code.ToString(CultureInfo.InvariantCulture)];
|
|
if (ce != null)
|
|
r = GetAbsoluteRedirect(ce.Redirect, basepath);
|
|
}
|
|
|
|
if (r == null) {
|
|
r = DefaultAbsolutePath;
|
|
}
|
|
|
|
return r;
|
|
}
|
|
|
|
protected override void Reset(ConfigurationElement parentElement) {
|
|
base.Reset(parentElement);
|
|
CustomErrorsSection parent = parentElement as CustomErrorsSection;
|
|
if (parent != null) {
|
|
basepath = parent.basepath;
|
|
}
|
|
}
|
|
|
|
protected override void DeserializeSection(XmlReader reader) {
|
|
WebContext context;
|
|
|
|
base.DeserializeSection(reader);
|
|
|
|
// Determine Web Context
|
|
context = EvaluationContext.HostingContext as WebContext;
|
|
|
|
if (context != null) {
|
|
basepath = UrlPath.AppendSlashToPathIfNeeded(context.Path);
|
|
}
|
|
}
|
|
//
|
|
// helper to create absolute redirect
|
|
//
|
|
internal static String GetAbsoluteRedirect(String path, String basePath) {
|
|
if (path != null && UrlPath.IsRelativeUrl(path)) {
|
|
if (String.IsNullOrEmpty(basePath))
|
|
basePath = "/";
|
|
|
|
path = UrlPath.Combine(basePath, path);
|
|
}
|
|
|
|
return path;
|
|
}
|
|
|
|
internal static CustomErrorsSection GetSettings(HttpContext context) {
|
|
return GetSettings(context, false);
|
|
}
|
|
|
|
internal static CustomErrorsSection GetSettings(HttpContext context, bool canThrow) {
|
|
CustomErrorsSection ce = null;
|
|
RuntimeConfig runtimeConfig = null;
|
|
if (canThrow) {
|
|
runtimeConfig = RuntimeConfig.GetConfig(context);
|
|
if (runtimeConfig != null) {
|
|
ce = runtimeConfig.CustomErrors;
|
|
}
|
|
}
|
|
else {
|
|
runtimeConfig = RuntimeConfig.GetLKGConfig(context);
|
|
if (runtimeConfig != null) {
|
|
ce = runtimeConfig.CustomErrors;
|
|
}
|
|
if (ce == null) {
|
|
if (_default == null) {
|
|
_default = new CustomErrorsSection();
|
|
}
|
|
|
|
ce = _default;
|
|
}
|
|
}
|
|
|
|
return ce;
|
|
}
|
|
|
|
internal bool CustomErrorsEnabled(HttpRequest request) {
|
|
// This could throw if the config file is malformed, but we don't want
|
|
// to throw from here, as it would mess up error handling
|
|
try {
|
|
// Always turn of custom errors in retail deployment mode (DevDiv 36396)
|
|
if (DeploymentSection.RetailInternal)
|
|
return true;
|
|
}
|
|
catch { }
|
|
|
|
switch (Mode) {
|
|
case CustomErrorsMode.Off:
|
|
return false;
|
|
|
|
case CustomErrorsMode.On:
|
|
return true;
|
|
|
|
case CustomErrorsMode.RemoteOnly:
|
|
return (!request.IsLocal);
|
|
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
}
|
|
}
|