Imported Upstream version 4.6.0.125

Former-commit-id: a2155e9bd80020e49e72e86c44da02a8ac0e57a4

mcs/class/referencesource/System.Web/Configuration/CustomErrorsSection.cs

@@ -0,0 +1,252 @@
+//------------------------------------------------------------------------------
+// <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;
+            }
+        }
+    }
+}