Files
dotnet-bot adf899c629 Adding System.Data..., System.ServiceModel..., and System.Web...
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
2016-05-03 00:07:37 +02:00

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;
}
}
}
}