linux-packaging-mono/mcs/class/referencesource/System.Web/Configuration/SessionStateSection.cs

//------------------------------------------------------------------------------
// <copyright file="SessionStateSection.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.Globalization;
    using System.IO;
    using System.Text;
    using System.ComponentModel;
    using System.Web.SessionState;
    using System.Diagnostics;
    using System.Security.Permissions;

    /*         <!-- sessionState Attributes:
                mode="[Off|InProc|StateServer|SQLServer|Custom]"
                stateConnectionString="tcpip=server:port"
                stateNetworkTimeout="timeout for network operations with State Server, in seconds"
                sqlConnectionString="valid System.Data.SqlClient.SqlConnection string, minus Initial Catalog"
                sqlCommandTimeout="timeout for SQL commands sent to SQL Server, in seconds"
                sqlConnectionRetryInterval="the interval the SQL State provider will retry opening connections and executing SQL commands when fatal errors occur, in seconds"
                customProvider="name of the custom provider"
                cookieless="[true|false|UseCookies|UseUri|AutoDetect|UseDeviceProfile]"
                cookieName="To override the default cookie name used for storing session ID"
                allowCustomSqlDatabase="[true|false]" - If true, the user can specify the Initial Catalog value in sqlConnectionString
                compressionEnabled="[true|false]"
                timeout="timeout in minutes"
                partitionResolverType="[fully qualified type of partition resolver]"
                useHostingIdentity="[true|false]"
                sessionIDManagerType="[fully qualified type of session ID Manager]"

              Child nodes:
                <providers>              Custom store providers (class must inherit SessionStateStoreProviderBase)
                    <add                 Add a provider
                        name="string"    Name to identify this provider instance by
                        type="string"    Class that implements ISessionStateStore
                        provider-specific-configuration />

                    <remove              Remove a provider
                        name="string" /> Name of provider to remove
                    <clear/>             Remove all providers
                </providers>
        -->
        <sessionState
            mode="InProc"
            stateConnectionString="tcpip=loopback:42424"
            stateNetworkTimeout="10"
            sqlConnectionString="data source=localhost;Integrated Security=SSPI"
            sqlCommandTimeout="30"
            customProvider=""
            cookieless="false"
            allowCustomSqlDatabase="false"
            compressionEnabled="false"
            regenerateExpiredSessionId="false"
            timeout="20"
        >
            <providers>
            </providers>
        </sessionState>

 */
    public sealed class SessionStateSection : ConfigurationSection {
        private static readonly ConfigurationElementProperty s_elemProperty =
            new ConfigurationElementProperty(new CallbackValidator(typeof(SessionStateSection), Validate));


        private static ConfigurationPropertyCollection _properties;

        private static readonly ConfigurationProperty _propMode =
            new ConfigurationProperty("mode",
                                        typeof(SessionStateMode),
                                        SessionStateModule.MODE_DEFAULT,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propStateConnectionString =
            new ConfigurationProperty("stateConnectionString",
                                        typeof(string),
                                        SessionStateModule.STATE_CONNECTION_STRING_DEFAULT,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propStateNetworkTimeout =
            new ConfigurationProperty("stateNetworkTimeout",
                                        typeof(TimeSpan),
#if FEATURE_PAL // FEATURE_PAL does not enable OutOfProcSessionStore
                                        TimeSpan.FromSeconds(600),
#else // FEATURE_PAL
                                        TimeSpan.FromSeconds((long)
                                            OutOfProcSessionStateStore.STATE_NETWORK_TIMEOUT_DEFAULT),
#endif // FEATURE_PAL
                                        StdValidatorsAndConverters.TimeSpanSecondsOrInfiniteConverter,
                                        StdValidatorsAndConverters.PositiveTimeSpanValidator,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propSqlConnectionString =
            new ConfigurationProperty("sqlConnectionString",
                                        typeof(string),
#if FEATURE_PAL // FEATURE_PAL does not enable SessionStateModule
                                        "data source=localhost;Integrated Security=SSPI",
#else // FEATURE_PAL
                                        SessionStateModule.SQL_CONNECTION_STRING_DEFAULT,
#endif // FEATURE_PAL
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propSqlCommandTimeout =
            new ConfigurationProperty("sqlCommandTimeout",
                                        typeof(TimeSpan),
#if FEATURE_PAL // FEATURE_PAL does not enable SqlSessionStateStore
                                        TimeSpan.FromSeconds(1800),
#else // FEATURE_PAL
                                        TimeSpan.FromSeconds((long)
                                            SqlSessionStateStore.SQL_COMMAND_TIMEOUT_DEFAULT),
#endif // FEATURE_PAL
                                        StdValidatorsAndConverters.TimeSpanSecondsOrInfiniteConverter,
                                        null,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propSqlConnectionRetryInterval =
                    new ConfigurationProperty("sqlConnectionRetryInterval",
                                                typeof(TimeSpan),
                                                TimeSpan.FromSeconds(0),
                                                StdValidatorsAndConverters.TimeSpanSecondsOrInfiniteConverter,
                                                null,
                                                ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propCustomProvider =
            new ConfigurationProperty("customProvider",
                                        typeof(string),
                                        String.Empty,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propCookieless =
            new ConfigurationProperty("cookieless",
                                        typeof(string),
                                        SessionIDManager.COOKIEMODE_DEFAULT.ToString(),
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propCookieName =
            new ConfigurationProperty("cookieName",
                                        typeof(string),
                                        SessionIDManager.SESSION_COOKIE_DEFAULT,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propTimeout =
            new ConfigurationProperty("timeout",
                                        typeof(TimeSpan),
                                        TimeSpan.FromMinutes((long)SessionStateModule.TIMEOUT_DEFAULT),
                                        StdValidatorsAndConverters.TimeSpanMinutesOrInfiniteConverter,
                                        new TimeSpanValidator(TimeSpan.FromMinutes(1), TimeSpan.MaxValue),
                                        ConfigurationPropertyOptions.None);
        private static readonly ConfigurationProperty _propAllowCustomSqlDatabase =
            new ConfigurationProperty("allowCustomSqlDatabase",
                                        typeof(bool),
                                        false,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propCompressionEnabled =
            new ConfigurationProperty("compressionEnabled",
                                        typeof(bool),
                                        false,
                                        ConfigurationPropertyOptions.None);


        //        private static readonly ConfigurationProperty _propLockAttributes =
        //            new ConfigurationProperty("lockAttributes",
        //                                    typeof(string),
        //                                    "",
        //                                    ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propProviders =
            new ConfigurationProperty("providers",
                                        typeof(ProviderSettingsCollection),
                                        null,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propRegenerateExpiredSessionId =
            new ConfigurationProperty("regenerateExpiredSessionId",
                                        typeof(bool),
                                        true,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propPartitionResolverType =
            new ConfigurationProperty("partitionResolverType",
                                        typeof(string),
                                        String.Empty,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propUseHostingIdentity =
            new ConfigurationProperty("useHostingIdentity",
                                        typeof(bool),
                                        true,
                                        ConfigurationPropertyOptions.None);

        private static readonly ConfigurationProperty _propSessionIDManagerType =
            new ConfigurationProperty("sessionIDManagerType",
                                        typeof(string),
                                        String.Empty,
                                        ConfigurationPropertyOptions.None);

        private HttpCookieMode cookielessCache = SessionIDManager.COOKIEMODE_DEFAULT;
        private bool cookielessCached = false;
        private bool regenerateExpiredSessionIdCache = false;
        private bool regenerateExpiredSessionIdCached = false;
        static SessionStateSection() {
            // Property initialization
            _properties = new ConfigurationPropertyCollection();
            _properties.Add(_propMode);
            _properties.Add(_propStateConnectionString);
            _properties.Add(_propStateNetworkTimeout);
            _properties.Add(_propSqlConnectionString);
            _properties.Add(_propSqlCommandTimeout);
            _properties.Add(_propSqlConnectionRetryInterval);
            _properties.Add(_propCustomProvider);
            _properties.Add(_propCookieless);
            _properties.Add(_propCookieName);
            _properties.Add(_propTimeout);
            _properties.Add(_propAllowCustomSqlDatabase);
            _properties.Add(_propCompressionEnabled);
            //            _properties.Add(_propLockAttributes);
            _properties.Add(_propProviders);
            _properties.Add(_propRegenerateExpiredSessionId);
            _properties.Add(_propPartitionResolverType);
            _properties.Add(_propUseHostingIdentity);
            _properties.Add(_propSessionIDManagerType);
        }

        public SessionStateSection() {
        }

        protected override ConfigurationPropertyCollection Properties {
            get {
                return _properties;
            }
        }

        [ConfigurationProperty("mode", DefaultValue = SessionStateModule.MODE_DEFAULT)]
        public SessionStateMode Mode {
            get {
                return (SessionStateMode)base[_propMode];
            }
            set {
                base[_propMode] = value;
            }
        }

        [ConfigurationProperty("stateConnectionString", DefaultValue = SessionStateModule.STATE_CONNECTION_STRING_DEFAULT)]
        public string StateConnectionString {
            get {
                return (string)base[_propStateConnectionString];
            }
            set {
                base[_propStateConnectionString] = value;
            }
        }

        [ConfigurationProperty("stateNetworkTimeout", DefaultValue = "00:00:10")]
        [TypeConverter(typeof(TimeSpanSecondsOrInfiniteConverter))]
        public TimeSpan StateNetworkTimeout {
            get {
                return (TimeSpan)base[_propStateNetworkTimeout];
            }
            set {
                base[_propStateNetworkTimeout] = value;
            }
        }

        [ConfigurationProperty("sqlConnectionString", DefaultValue = SessionStateModule.SQL_CONNECTION_STRING_DEFAULT)]
        public string SqlConnectionString {
            get {
                return (string)base[_propSqlConnectionString];
            }
            set {
                base[_propSqlConnectionString] = value;
            }
        }

        [ConfigurationProperty("sqlCommandTimeout", DefaultValue = "00:00:30")]
        [TypeConverter(typeof(TimeSpanSecondsOrInfiniteConverter))]
        public TimeSpan SqlCommandTimeout {
            get {
                return (TimeSpan)base[_propSqlCommandTimeout];
            }
            set {
                base[_propSqlCommandTimeout] = value;
            }
        }

        [ConfigurationProperty("sqlConnectionRetryInterval", DefaultValue = "00:00:00")]
        [TypeConverter(typeof(TimeSpanSecondsOrInfiniteConverter))]
        public TimeSpan SqlConnectionRetryInterval {
            get {
                return (TimeSpan)base[_propSqlConnectionRetryInterval];
            }
            set {
                base[_propSqlConnectionRetryInterval] = value;
            }
        }


        [ConfigurationProperty("customProvider", DefaultValue = "")]
        public string CustomProvider {
            get {
                return (string)base[_propCustomProvider];
            }
            set {
                base[_propCustomProvider] = value;
            }
        }

        [ConfigurationProperty("cookieless")]
        public HttpCookieMode Cookieless {
            get {
                if (cookielessCached == false) {
                    cookielessCache = ConvertToCookieMode((string)base[_propCookieless]);
                    cookielessCached = true;
                }
                return cookielessCache;
            }
            set {
                base[_propCookieless] = value.ToString();
                cookielessCache = value;
            }
        }

        [ConfigurationProperty("cookieName", DefaultValue = SessionIDManager.SESSION_COOKIE_DEFAULT)]
        public string CookieName {
            get {
                return (string)base[_propCookieName];
            }
            set {
                base[_propCookieName] = value;
            }
        }

        [ConfigurationProperty("timeout", DefaultValue = "00:20:00")]
        [TypeConverter(typeof(TimeSpanMinutesOrInfiniteConverter))]
        [TimeSpanValidator(MinValueString = "00:01:00", MaxValueString = TimeSpanValidatorAttribute.TimeSpanMaxValue)]
        public TimeSpan Timeout {
            get {
                return (TimeSpan)base[_propTimeout];
            }
            set {
                base[_propTimeout] = value;
            }
        }

        [ConfigurationProperty("allowCustomSqlDatabase", DefaultValue = false)]
        public bool AllowCustomSqlDatabase {
            get {
                return (bool)base[_propAllowCustomSqlDatabase];
            }
            set {
                base[_propAllowCustomSqlDatabase] = value;
            }
        }

        [ConfigurationProperty("compressionEnabled", DefaultValue = false)]
        public bool CompressionEnabled{
            get {
                return (bool)base[_propCompressionEnabled];
            }
            set {
                base[_propCompressionEnabled] = value;
            }
        }

        [ConfigurationProperty("regenerateExpiredSessionId", DefaultValue = true)]
        public bool RegenerateExpiredSessionId {
            get {
                if (regenerateExpiredSessionIdCached == false) {
                    regenerateExpiredSessionIdCache = (bool)base[_propRegenerateExpiredSessionId];
                    regenerateExpiredSessionIdCached = true;
                }
                return regenerateExpiredSessionIdCache;
            }
            set {
                base[_propRegenerateExpiredSessionId] = value;
                regenerateExpiredSessionIdCache = value;
            }
        }


#if DONTCOMPILE
        [ConfigurationProperty("lockAttributes", DefaultValue = "")]
        public string LockAttributes {
            get {
                return (string)base[_propLockAttributes];
            }
            set {
                // base.LockedAttributes.SetFromList(value); // keep the internal list in sync
                base[_propLockAttributes] = value;
            }
        }
#endif

        [ConfigurationProperty("providers")]
        public ProviderSettingsCollection Providers {
            get {
                return (ProviderSettingsCollection)base[_propProviders];
            }
        }

        [ConfigurationProperty("partitionResolverType", DefaultValue = "")]
        public string PartitionResolverType {
            get {
                return (string)base[_propPartitionResolverType];
            }
            set {
                base[_propPartitionResolverType] = value;
            }
        }

        [ConfigurationProperty("useHostingIdentity", DefaultValue = true)]
        public bool UseHostingIdentity {
            get {
                return (bool)base[_propUseHostingIdentity];
            }
            set {
                base[_propUseHostingIdentity] = value;
            }
        }

        [ConfigurationProperty("sessionIDManagerType", DefaultValue = "")]
        public string SessionIDManagerType {
            get {
                return (string)base[_propSessionIDManagerType];
            }
            set {
                base[_propSessionIDManagerType] = value;
            }
        }


        HttpCookieMode ConvertToCookieMode(string s) {
            if (s == "true") {
                return HttpCookieMode.UseUri;
            }
            else if (s == "false") {
                return HttpCookieMode.UseCookies;
            }
            else {
                int iTemp = 0;
                Type enumType = typeof(HttpCookieMode);

                if (Enum.IsDefined(enumType, s)) {
                    iTemp = (int)Enum.Parse(enumType, s);
                }
                else {
                    // if not null and not defined throw error
                    string names = "true, false";
                    foreach (string name in Enum.GetNames(enumType)) {
                        if (names == null) {
                            names = name;
                        }
                        else {
                            names += ", " + name;
                        }
                    }

                    throw new ConfigurationErrorsException(
                        SR.GetString(SR.Invalid_enum_attribute, "cookieless", names),
                        ElementInformation.Properties["cookieless"].Source,
                        ElementInformation.Properties["cookieless"].LineNumber);
                }

                return (HttpCookieMode)iTemp;
            }
        }

        protected override void PostDeserialize() {
            ConvertToCookieMode((string)base[_propCookieless]);
        }

        protected override ConfigurationElementProperty ElementProperty {
            get {
                return s_elemProperty;
            }
        }

        private static void Validate(object value) {
            if (value == null) {
                throw new ArgumentNullException("sessionState");
            }
            Debug.Assert(value is SessionStateSection);

            SessionStateSection elem = (SessionStateSection)value;

            if (elem.Timeout.TotalMinutes > SessionStateModule.MAX_CACHE_BASED_TIMEOUT_MINUTES &&
                (elem.Mode == SessionStateMode.InProc ||
                elem.Mode == SessionStateMode.StateServer)) {
                throw new ConfigurationErrorsException(
                    SR.GetString(SR.Invalid_cache_based_session_timeout),
                    elem.ElementInformation.Properties["timeout"].Source,
                    elem.ElementInformation.Properties["timeout"].LineNumber);
            }
        }
    }
}