Umbraco-CMS/src/Umbraco.Core/Configuration/GlobalSettings.cs

using System;
using System.Collections.Generic;
using System.Configuration;
using System.Linq;
using System.Net.Configuration;
using System.Web;
using System.Web.Configuration;
using System.Web.Hosting;
using System.Web.Routing;
using System.Web.Security;
using System.Xml;
using System.Xml.Linq;
using System.Xml.XPath;
using Umbraco.Core.IO;
using Umbraco.Core.Logging;
using Umbraco.Core.Security;

namespace Umbraco.Core.Configuration
{
    //NOTE: Do not expose this class ever until we cleanup all configuration including removal of static classes, etc...
    // we have this two tasks logged:
    // http://issues.umbraco.org/issue/U4-58
    // http://issues.umbraco.org/issue/U4-115	

    //TODO:  Replace checking for if the app settings exist and returning an empty string, instead return the defaults!

    /// <summary>
    /// The GlobalSettings Class contains general settings information for the entire Umbraco instance based on information from  web.config appsettings 
    /// </summary>
    internal class GlobalSettings
    {

        #region Private static fields

        private static Version _version;
        private static readonly object Locker = new object();
        //make this volatile so that we can ensure thread safety with a double check lock
    	private static volatile string _reservedUrlsCache;
        private static string _reservedPathsCache;
        private static HashSet<string> _reservedList = new HashSet<string>();
        private static string _reservedPaths;
        private static string _reservedUrls;
        //ensure the built on (non-changeable) reserved paths are there at all times
        private const string StaticReservedPaths = "~/app_plugins/,~/install/,";
        private const string StaticReservedUrls = "~/config/splashes/booting.aspx,~/config/splashes/noNodes.aspx,~/VSEnterpriseHelper.axd,";
        #endregion

        /// <summary>
        /// Used in unit testing to reset all config items that were set with property setters (i.e. did not come from config)
        /// </summary>
        private static void ResetInternal()
        {
            _reservedUrlsCache = null;
            _reservedPaths = null;
            _reservedUrls = null;
            HasSmtpServer = null;
        }

        /// <summary>
        /// Resets settings that were set programmatically, to their initial values.
        /// </summary>
        /// <remarks>To be used in unit tests.</remarks>
        internal static void Reset()
        {
            ResetInternal();
        }

        public static bool HasSmtpServerConfigured(string appPath)
        {
            if (HasSmtpServer.HasValue) return HasSmtpServer.Value;

            var config = WebConfigurationManager.OpenWebConfiguration(appPath);
            var settings = (MailSettingsSectionGroup)config.GetSectionGroup("system.net/mailSettings");
            if (settings == null || settings.Smtp == null) return false;
            if (settings.Smtp.SpecifiedPickupDirectory != null && string.IsNullOrEmpty(settings.Smtp.SpecifiedPickupDirectory.PickupDirectoryLocation) == false)
                return true;
            if (settings.Smtp.Network != null && string.IsNullOrEmpty(settings.Smtp.Network.Host) == false)
                return true;
            return false;
        }

        /// <summary>
        /// For testing only
        /// </summary>
        internal static bool? HasSmtpServer { get; set; }

        /// <summary>
        /// Gets the reserved urls from web.config.
        /// </summary>
        /// <value>The reserved urls.</value>
        public static string ReservedUrls
        {
            get
            {                
                if (_reservedUrls == null)
                {
                    var urls = ConfigurationManager.AppSettings.ContainsKey("umbracoReservedUrls")
                                   ? ConfigurationManager.AppSettings["umbracoReservedUrls"]
                                   : string.Empty;

                    //ensure the built on (non-changeable) reserved paths are there at all times
                    _reservedUrls = StaticReservedUrls + urls;    
                }
                return _reservedUrls;
            }
            internal set { _reservedUrls = value; }
        }

        /// <summary>
        /// Gets the reserved paths from web.config
        /// </summary>
        /// <value>The reserved paths.</value>
        public static string ReservedPaths
        {
            get
            {
                if (_reservedPaths == null)
                {
                    var reservedPaths = StaticReservedPaths;
                    //always add the umbraco path to the list
                    if (ConfigurationManager.AppSettings.ContainsKey("umbracoPath")
                        && !ConfigurationManager.AppSettings["umbracoPath"].IsNullOrWhiteSpace())
                    {
                        reservedPaths += ConfigurationManager.AppSettings["umbracoPath"].EnsureEndsWith(',');
                    }

                    var allPaths = ConfigurationManager.AppSettings.ContainsKey("umbracoReservedPaths")
                                    ? ConfigurationManager.AppSettings["umbracoReservedPaths"]
                                    : string.Empty;

                    _reservedPaths = reservedPaths + allPaths;
                }
                return _reservedPaths;
            }
            internal set { _reservedPaths = value; }
        }

        /// <summary>
        /// Gets the name of the content XML file.
        /// </summary>
        /// <value>The content XML.</value>
        /// <remarks>
        /// Defaults to ~/App_Data/umbraco.config
        /// </remarks>
        public static string ContentXmlFile
        {
            get
            {
                return ConfigurationManager.AppSettings.ContainsKey("umbracoContentXML")
                    ? ConfigurationManager.AppSettings["umbracoContentXML"]
                    : "~/App_Data/umbraco.config";
            }
        }

        /// <summary>
        /// Gets the path to the storage directory (/data by default).
        /// </summary>
        /// <value>The storage directory.</value>
        public static string StorageDirectory
        {
            get
            {
                return ConfigurationManager.AppSettings.ContainsKey("umbracoStorageDirectory")
                    ? ConfigurationManager.AppSettings["umbracoStorageDirectory"]
                    : "~/App_Data";
            }
        }

        /// <summary>
        /// Gets the path to umbraco's root directory (/umbraco by default).
        /// </summary>
        /// <value>The path.</value>
        public static string Path
        {
            get
            {
                return ConfigurationManager.AppSettings.ContainsKey("umbracoPath")
                    ? IOHelper.ResolveUrl(ConfigurationManager.AppSettings["umbracoPath"])
                    : string.Empty;
            }
        }

        /// <summary>
        /// This returns the string of the MVC Area route.
        /// </summary>
        /// <remarks>
        /// THIS IS TEMPORARY AND SHOULD BE REMOVED WHEN WE MIGRATE/UPDATE THE CONFIG SETTINGS TO BE A REAL CONFIG SECTION
        /// AND SHOULD PROBABLY BE HANDLED IN A MORE ROBUST WAY.
        /// 
        /// This will return the MVC area that we will route all custom routes through like surface controllers, etc...
        /// We will use the 'Path' (default ~/umbraco) to create it but since it cannot contain '/' and people may specify a path of ~/asdf/asdf/admin
        /// we will convert the '/' to '-' and use that as the path. its a bit lame but will work.
		/// 
        /// We also make sure that the virtual directory (SystemDirectories.Root) is stripped off first, otherwise we'd end up with something
        /// like "MyVirtualDirectory-Umbraco" instead of just "Umbraco".
        /// </remarks>
        public static string UmbracoMvcArea
        {
            get
            {
                if (Path.IsNullOrWhiteSpace())
                {
                    throw new InvalidOperationException("Cannot create an MVC Area path without the umbracoPath specified");
                }
                var path = Path;
                if (path.StartsWith(SystemDirectories.Root)) // beware of TrimStart, see U4-2518
                    path = path.Substring(SystemDirectories.Root.Length);
			    return path.TrimStart('~').TrimStart('/').Replace('/', '-').Trim().ToLower();
            }
        }

        /// <summary>
        /// Gets the path to umbraco's client directory (/umbraco_client by default).
        /// This is a relative path to the Umbraco Path as it always must exist beside the 'umbraco'
        /// folder since the CSS paths to images depend on it.
        /// </summary>
        /// <value>The path.</value>
        public static string ClientPath
        {
            get
            {
                return Path + "/../umbraco_client";
            }
        }

        /// <summary>
        /// Gets the database connection string
        /// </summary>
        /// <value>The database connection string.</value>
        [Obsolete("Use System.Configuration.ConfigurationManager.ConnectionStrings[\"umbracoDbDSN\"] instead")]
        public static string DbDsn
        {
            get
            {
                var settings = ConfigurationManager.ConnectionStrings[Constants.System.UmbracoConnectionName];
                var connectionString = string.Empty;

                if (settings != null)
                {
                    connectionString = settings.ConnectionString;

                    // The SqlCe connectionString is formatted slightly differently, so we need to update it
                    if (settings.ProviderName.Contains("SqlServerCe"))
                        connectionString = string.Format("datalayer=SQLCE4Umbraco.SqlCEHelper,SQLCE4Umbraco;{0}", connectionString);
                }

                return connectionString;
            }
            set
            {
                if (DbDsn != value)
                {
                    if (value.ToLower().Contains("SQLCE4Umbraco.SqlCEHelper".ToLower()))
                    {
                        ApplicationContext.Current.DatabaseContext.ConfigureEmbeddedDatabaseConnection();
                    }
                    else
                    {
                        ApplicationContext.Current.DatabaseContext.ConfigureDatabaseConnection(value);
                    } 
                }
            }
        }
        

        /// <summary>
        /// Gets or sets the configuration status. This will return the version number of the currently installed umbraco instance.
        /// </summary>
        /// <value>The configuration status.</value>
        public static string ConfigurationStatus
        {
            get
            {
                return ConfigurationManager.AppSettings.ContainsKey("umbracoConfigurationStatus")
                    ? ConfigurationManager.AppSettings["umbracoConfigurationStatus"]
                    : string.Empty;
            }
            set
            {
                SaveSetting("umbracoConfigurationStatus", value);
            }
        }
        
        /// <summary>
        /// Gets or sets the Umbraco members membership providers' useLegacyEncoding state. This will return a boolean
        /// </summary>
        /// <value>The useLegacyEncoding status.</value>
        public static bool UmbracoMembershipProviderLegacyEncoding
        {
            get
            {
                return IsConfiguredMembershipProviderUsingLegacyEncoding(Constants.Conventions.Member.UmbracoMemberProviderName);
            }
            set
            {
                SetMembershipProvidersLegacyEncoding(Constants.Conventions.Member.UmbracoMemberProviderName, value);
            }
        }
        
        /// <summary>
        /// Gets or sets the Umbraco users membership providers' useLegacyEncoding state. This will return a boolean
        /// </summary>
        /// <value>The useLegacyEncoding status.</value>
        public static bool UmbracoUsersMembershipProviderLegacyEncoding
        {
            get
            {
                return IsConfiguredMembershipProviderUsingLegacyEncoding(UmbracoConfig.For.UmbracoSettings().Providers.DefaultBackOfficeUserProvider);
            }
            set
            {
                SetMembershipProvidersLegacyEncoding(UmbracoConfig.For.UmbracoSettings().Providers.DefaultBackOfficeUserProvider, value);
            }
        }
		
        /// <summary>
        /// Saves a setting into the configuration file.
        /// </summary>
        /// <param name="key">Key of the setting to be saved.</param>
        /// <param name="value">Value of the setting to be saved.</param>
        internal static void SaveSetting(string key, string value)
        {
            var fileName = IOHelper.MapPath(string.Format("{0}/web.config", SystemDirectories.Root));
            var xml = XDocument.Load(fileName, LoadOptions.PreserveWhitespace);

            var appSettings = xml.Root.DescendantsAndSelf("appSettings").Single();

            // Update appSetting if it exists, or else create a new appSetting for the given key and value
            var setting = appSettings.Descendants("add").FirstOrDefault(s => s.Attribute("key").Value == key);
            if (setting == null)
                appSettings.Add(new XElement("add", new XAttribute("key", key), new XAttribute("value", value)));
            else
                setting.Attribute("value").Value = value;

            xml.Save(fileName, SaveOptions.DisableFormatting);
            ConfigurationManager.RefreshSection("appSettings");
        }

        /// <summary>
        /// Removes a setting from the configuration file.
        /// </summary>
        /// <param name="key">Key of the setting to be removed.</param>
        internal static void RemoveSetting(string key)
        {
            var fileName = IOHelper.MapPath(string.Format("{0}/web.config", SystemDirectories.Root));
            var xml = XDocument.Load(fileName, LoadOptions.PreserveWhitespace);

            var appSettings = xml.Root.DescendantsAndSelf("appSettings").Single();
            var setting = appSettings.Descendants("add").FirstOrDefault(s => s.Attribute("key").Value == key);

            if (setting != null)
            {
                setting.Remove();
                xml.Save(fileName, SaveOptions.DisableFormatting);
                ConfigurationManager.RefreshSection("appSettings");
            }        
        }

        private static void SetMembershipProvidersLegacyEncoding(string providerName, bool useLegacyEncoding)
        {
            //check if this can even be configured.
            var membershipProvider = Membership.Providers[providerName] as MembershipProviderBase;
            if (membershipProvider == null)
            {
                return;
            }
            if (membershipProvider.GetType().Namespace == "umbraco.providers.members")
            {
                //its the legacy one, this cannot be changed
                return;
            }

            var webConfigFilename = IOHelper.MapPath(string.Format("{0}/web.config", SystemDirectories.Root));
            var webConfigXml = XDocument.Load(webConfigFilename, LoadOptions.PreserveWhitespace);

            var membershipConfigs = webConfigXml.XPathSelectElements("configuration/system.web/membership/providers/add").ToList();

            if (membershipConfigs.Any() == false) 
                return;

            var provider = membershipConfigs.SingleOrDefault(c => c.Attribute("name") != null && c.Attribute("name").Value == providerName);

            if (provider == null) 
                return;

            provider.SetAttributeValue("useLegacyEncoding", useLegacyEncoding);
            
            webConfigXml.Save(webConfigFilename, SaveOptions.DisableFormatting);
        }

        private static bool IsConfiguredMembershipProviderUsingLegacyEncoding(string providerName)
        {
            //check if this can even be configured.
            var membershipProvider = Membership.Providers[providerName] as MembershipProviderBase;
            if (membershipProvider == null)
            {
                return false;
            }

            return membershipProvider.UseLegacyEncoding;            
        }

        /// <summary>
        /// Gets the full path to root.
        /// </summary>
        /// <value>The fullpath to root.</value>
        public static string FullpathToRoot
        {
            get { return IOHelper.GetRootDirectorySafe(); }
        }

        /// <summary>
        /// Gets a value indicating whether umbraco is running in [debug mode].
        /// </summary>
        /// <value><c>true</c> if [debug mode]; otherwise, <c>false</c>.</value>
        public static bool DebugMode
        {
            get
            {
                try
                {
                    if (HttpContext.Current != null)
                    {
                        return HttpContext.Current.IsDebuggingEnabled;
                    }
                    //go and get it from config directly
                    var section = ConfigurationManager.GetSection("system.web/compilation") as CompilationSection;
                    return section != null && section.Debug;
                }
                catch
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// Gets a value indicating whether the current version of umbraco is configured.
        /// </summary>
        /// <value><c>true</c> if configured; otherwise, <c>false</c>.</value>
        [Obsolete("Do not use this, it is no longer in use and will be removed from the codebase in future versions")]
        internal static bool Configured
        {
            get
            {
                try
                {
                    string configStatus = ConfigurationStatus;
                    string currentVersion = UmbracoVersion.GetSemanticVersion().ToSemanticString();


                    if (currentVersion != configStatus)
                    {
                        LogHelper.Debug<GlobalSettings>("CurrentVersion different from configStatus: '" + currentVersion + "','" + configStatus + "'");
                    }


                    return (configStatus == currentVersion);
                }
                catch
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// Gets the time out in minutes.
        /// </summary>
        /// <value>The time out in minutes.</value>
        public static int TimeOutInMinutes
        {
            get
            {
                try
                {
                    return int.Parse(ConfigurationManager.AppSettings["umbracoTimeOutInMinutes"]);
                }
                catch
                {
                    return 20;
                }
            }
        }

        /// <summary>
        /// Gets a value indicating whether umbraco uses directory urls.
        /// </summary>
        /// <value><c>true</c> if umbraco uses directory urls; otherwise, <c>false</c>.</value>
        public static bool UseDirectoryUrls
        {
            get
            {
                try
                {
                    return bool.Parse(ConfigurationManager.AppSettings["umbracoUseDirectoryUrls"]);
                }
                catch
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// Returns a string value to determine if umbraco should skip version-checking.
        /// </summary>
        /// <value>The version check period in days (0 = never).</value>
        public static int VersionCheckPeriod
        {
            get
            {
                try
                {
                    return int.Parse(ConfigurationManager.AppSettings["umbracoVersionCheckPeriod"]);
                }
                catch
                {
                    return 7;
                }
            }
        }

        /// <summary>
        /// Returns a string value to determine if umbraco should disbable xslt extensions
        /// </summary>
        /// <value><c>"true"</c> if version xslt extensions are disabled, otherwise, <c>"false"</c></value>
        [Obsolete("This is no longer used and will be removed from the codebase in future releases")]
        public static string DisableXsltExtensions
        {
            get
            {
                return ConfigurationManager.AppSettings.ContainsKey("umbracoDisableXsltExtensions")
                    ? ConfigurationManager.AppSettings["umbracoDisableXsltExtensions"]
                    : "false";
            }
        }

        internal static bool ContentCacheXmlStoredInCodeGen
        {
            get { return LocalTempStorageLocation == LocalTempStorage.AspNetTemp; }
        }

        /// <summary>
        /// This is the location type to store temporary files such as cache files or other localized files for a given machine
        /// </summary>
        /// <remarks>
        /// Currently used for the xml cache file and the plugin cache files
        /// </remarks>
        internal static LocalTempStorage LocalTempStorageLocation
        {
            get
            {
                //there's a bunch of backwards compat config checks here....

                //This is the current one
                if (ConfigurationManager.AppSettings.ContainsKey("umbracoLocalTempStorage"))
                {
                    return Enum<LocalTempStorage>.Parse(ConfigurationManager.AppSettings["umbracoLocalTempStorage"]);
                }

                //This one is old
                if (ConfigurationManager.AppSettings.ContainsKey("umbracoContentXMLStorage"))
                {
                    return Enum<LocalTempStorage>.Parse(ConfigurationManager.AppSettings["umbracoContentXMLStorage"]);
                }

                //This one is older
                if (ConfigurationManager.AppSettings.ContainsKey("umbracoContentXMLUseLocalTemp"))
                {
                    return bool.Parse(ConfigurationManager.AppSettings["umbracoContentXMLUseLocalTemp"]) 
                        ? LocalTempStorage.AspNetTemp 
                        : LocalTempStorage.Default;
                }
                return LocalTempStorage.Default;
            }
        }

        /// <summary>
        /// Returns a string value to determine if umbraco should use Xhtml editing mode in the wysiwyg editor
        /// </summary>
        /// <value><c>"true"</c> if Xhtml mode is enable, otherwise, <c>"false"</c></value>
        [Obsolete("This is no longer used and will be removed from the codebase in future releases")]
        public static string EditXhtmlMode
        {
            get { return "true"; }
        }

        /// <summary>
        /// Gets the default UI language.
        /// </summary>
        /// <value>The default UI language.</value>
        public static string DefaultUILanguage
        {
            get
            {
                return ConfigurationManager.AppSettings.ContainsKey("umbracoDefaultUILanguage")
                    ? ConfigurationManager.AppSettings["umbracoDefaultUILanguage"]
                    : string.Empty;
            }
        }

        /// <summary>
        /// Gets the profile URL.
        /// </summary>
        /// <value>The profile URL.</value>
        public static string ProfileUrl
        {
            get
            {
                //the default will be 'profiler'
                return ConfigurationManager.AppSettings.ContainsKey("umbracoProfileUrl")
                    ? ConfigurationManager.AppSettings["umbracoProfileUrl"]
                    : "profiler";
            }
        }

        /// <summary>
        /// Gets a value indicating whether umbraco should hide top level nodes from generated urls.
        /// </summary>
        /// <value>
        /// 	<c>true</c> if umbraco hides top level nodes from urls; otherwise, <c>false</c>.
        /// </value>
        public static bool HideTopLevelNodeFromPath
        {
            get
            {
                try
                {
                    return bool.Parse(ConfigurationManager.AppSettings["umbracoHideTopLevelNodeFromPath"]);
                }
                catch
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// Gets the current version.
        /// </summary>
        /// <value>The current version.</value>
        [Obsolete("Use Umbraco.Core.Configuration.UmbracoVersion.Current instead", false)]
        public static string CurrentVersion
        {
            get { return UmbracoVersion.GetSemanticVersion().ToSemanticString(); }
        }

        /// <summary>
        /// Gets the major version number.
        /// </summary>
        /// <value>The major version number.</value>
        [Obsolete("Use Umbraco.Core.Configuration.UmbracoVersion.Current instead", false)]
        public static int VersionMajor
        {
            get
            {
                return UmbracoVersion.Current.Major;
            }
        }

        /// <summary>
        /// Gets the minor version number.
        /// </summary>
        /// <value>The minor version number.</value>
        [Obsolete("Use Umbraco.Core.Configuration.UmbracoVersion.Current instead", false)]
        public static int VersionMinor
        {
            get
            {
                return UmbracoVersion.Current.Minor;
            }
        }

        /// <summary>
        /// Gets the patch version number.
        /// </summary>
        /// <value>The patch version number.</value>
        [Obsolete("Use Umbraco.Core.Configuration.UmbracoVersion.Current instead", false)]
        public static int VersionPatch
        {
            get
            {
                return UmbracoVersion.Current.Build;
            }
        }

        /// <summary>
        /// Gets the version comment (like beta or RC).
        /// </summary>
        /// <value>The version comment.</value>
        [Obsolete("Use Umbraco.Core.Configuration.UmbracoVersion.Current instead", false)]
        public static string VersionComment
        {
            get
            {
                return Umbraco.Core.Configuration.UmbracoVersion.CurrentComment;
            }
        }


        /// <summary>
        /// Requests the is in umbraco application directory structure.
        /// </summary>
        /// <param name="context">The context.</param>
        /// <returns></returns>
        public static bool RequestIsInUmbracoApplication(HttpContext context)
        {
            return context.Request.Path.ToLower().IndexOf(IOHelper.ResolveUrl(SystemDirectories.Umbraco).ToLower()) > -1;
        }

        public static bool RequestIsInUmbracoApplication(HttpContextBase context)
        {
            return context.Request.Path.ToLower().IndexOf(IOHelper.ResolveUrl(SystemDirectories.Umbraco).ToLower()) > -1;
        }

        /// <summary>
        /// Gets a value indicating whether umbraco should force a secure (https) connection to the backoffice.
        /// </summary>
        /// <value><c>true</c> if [use SSL]; otherwise, <c>false</c>.</value>
        public static bool UseSSL
        {
            get
            {
                try
                {
                    return bool.Parse(ConfigurationManager.AppSettings["umbracoUseSSL"]);
                }
                catch
                {
                    return false;
                }
            }
        }

        /// <summary>
        /// Gets the umbraco license.
        /// </summary>
        /// <value>The license.</value>
        public static string License
        {
            get
            {
                string license =
                    "<A href=\"http://umbraco.org/redir/license\" target=\"_blank\">the open source license MIT</A>. The umbraco UI is freeware licensed under the umbraco license.";

                var versionDoc = new XmlDocument();
                var versionReader = new XmlTextReader(IOHelper.MapPath(SystemDirectories.Umbraco + "/version.xml"));
                versionDoc.Load(versionReader);
                versionReader.Close();

                // check for license
                try
                {
                    string licenseUrl =
                        versionDoc.SelectSingleNode("/version/licensing/licenseUrl").FirstChild.Value;
                    string licenseValidation =
                        versionDoc.SelectSingleNode("/version/licensing/licenseValidation").FirstChild.Value;
                    string licensedTo =
                        versionDoc.SelectSingleNode("/version/licensing/licensedTo").FirstChild.Value;

                    if (licensedTo != "" && licenseUrl != "")
                    {
                        license = "umbraco Commercial License<br/><b>Registered to:</b><br/>" +
                                  licensedTo.Replace("\n", "<br/>") + "<br/><b>For use with domain:</b><br/>" +
                                  licenseUrl;
                    }
                }
                catch
                {
                }

                return license;
            }
        }

        /// <summary>
        /// Determines whether the current request is reserved based on the route table and 
        /// whether the specified URL is reserved or is inside a reserved path.
        /// </summary>
        /// <param name="url"></param>
        /// <param name="httpContext"></param>
        /// <param name="routes">The route collection to lookup the request in</param>
        /// <returns></returns>
        public static bool IsReservedPathOrUrl(string url, HttpContextBase httpContext, RouteCollection routes)
        {
            if (httpContext == null) throw new ArgumentNullException("httpContext");
            if (routes == null) throw new ArgumentNullException("routes");

            //check if the current request matches a route, if so then it is reserved.
            var route = routes.GetRouteData(httpContext);
            if (route != null)
                return true;

            //continue with the standard ignore routine
            return IsReservedPathOrUrl(url);
        }

        /// <summary>
        /// Determines whether the specified URL is reserved or is inside a reserved path.
        /// </summary>
        /// <param name="url">The URL to check.</param>
        /// <returns>
        /// 	<c>true</c> if the specified URL is reserved; otherwise, <c>false</c>.
        /// </returns>
        public static bool IsReservedPathOrUrl(string url)
        {
            if (_reservedUrlsCache == null)
            {
                lock (Locker)
                {
                    if (_reservedUrlsCache == null)
                    {
                        // store references to strings to determine changes
                        _reservedPathsCache = GlobalSettings.ReservedPaths;
                        _reservedUrlsCache = GlobalSettings.ReservedUrls;
                        
                        // add URLs and paths to a new list
                        var newReservedList = new HashSet<string>();
                        foreach (var reservedUrlTrimmed in _reservedUrlsCache
                            .Split(new[] {","}, StringSplitOptions.RemoveEmptyEntries)
                            .Select(x => x.Trim().ToLowerInvariant())
                            .Where(x => x.IsNullOrWhiteSpace() == false)
                            .Select(reservedUrl => IOHelper.ResolveUrl(reservedUrl).Trim().EnsureStartsWith("/"))
                            .Where(reservedUrlTrimmed => reservedUrlTrimmed.IsNullOrWhiteSpace() == false))
                        {
                            newReservedList.Add(reservedUrlTrimmed);
                        }

                        foreach (var reservedPathTrimmed in _reservedPathsCache
                            .Split(new[] {","}, StringSplitOptions.RemoveEmptyEntries)
                            .Select(x => x.Trim().ToLowerInvariant())
                            .Where(x => x.IsNullOrWhiteSpace() == false)
                            .Select(reservedPath => IOHelper.ResolveUrl(reservedPath).Trim().EnsureStartsWith("/").EnsureEndsWith("/"))
                            .Where(reservedPathTrimmed => reservedPathTrimmed.IsNullOrWhiteSpace() == false))
                        {
                            newReservedList.Add(reservedPathTrimmed);
                        }

                        // use the new list from now on
                        _reservedList = newReservedList;
                    }
                }
            }

            //The url should be cleaned up before checking:
            // * If it doesn't contain an '.' in the path then we assume it is a path based URL, if that is the case we should add an trailing '/' because all of our reservedPaths use a trailing '/'
            // * We shouldn't be comparing the query at all
            var pathPart = url.Split(new[] {'?'}, StringSplitOptions.RemoveEmptyEntries)[0].ToLowerInvariant();
            if (pathPart.Contains(".") == false)
            {
                pathPart = pathPart.EnsureEndsWith('/');
            }

            // return true if url starts with an element of the reserved list
            return _reservedList.Any(x => pathPart.InvariantStartsWith(x));
        }

      

    }




}