885 lines
41 KiB
C#
885 lines
41 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="HttpRuntimeSection.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
|
|
namespace System.Web.Configuration {
|
|
using System;
|
|
using System.ComponentModel;
|
|
using System.Configuration;
|
|
using System.Runtime.Versioning;
|
|
using System.Text;
|
|
using System.Web.Security.AntiXss;
|
|
using System.Web.Util;
|
|
|
|
public sealed class HttpRuntimeSection : ConfigurationSection {
|
|
#if !FEATURE_PAL // FEATURE_PAL-specific timeout values
|
|
internal const int DefaultExecutionTimeout = 110;
|
|
#else // !FEATURE_PAL
|
|
// The timeout needs to be extended, since Coriolis/Rotor is much slower
|
|
// especially platforms like Solaris wan't be able to process complicated
|
|
// requests if in debug mode.
|
|
// Remove or change this once the real timeout is known
|
|
#if DEBUG
|
|
internal const int DefaultExecutionTimeout = 110 * 10;
|
|
#else // DEBUG
|
|
internal const int DefaultExecutionTimeout = 110 * 5;
|
|
#endif // DEBUG
|
|
|
|
#endif // !FEATURE_PAL
|
|
internal const int DefaultMaxRequestLength = 4096 * 1024; // 4MB
|
|
internal const int DefaultRequestLengthDiskThreshold = 80 * 1024; // 80KB
|
|
internal const int DefaultMinFreeThreads = 8;
|
|
internal const int DefaultMinLocalRequestFreeThreads = 4;
|
|
internal const int DefaultAppRequestQueueLimit = 100;
|
|
internal const int DefaultShutdownTimeout = 90;
|
|
internal const int DefaultDelayNotificationTimeout = 0;
|
|
internal const int DefaultWaitChangeNotification = 0;
|
|
internal const int DefaultMaxWaitChangeNotification = 0;
|
|
internal const bool DefaultAllowDynamicModuleRegistration = true;
|
|
internal const bool DefaultEnableKernelOutputCache = true;
|
|
internal const bool DefaultRequireRootedSaveAsPath = true;
|
|
internal const bool DefaultSendCacheControlHeader = true;
|
|
internal const string DefaultEncoderType = "System.Web.Util.HttpEncoder";
|
|
internal static readonly Version DefaultRequestValidationMode = VersionUtil.FrameworkDefault;
|
|
internal const string DefaultRequestValidationModeString = VersionUtil.FrameworkDefaultString;
|
|
internal const string DefaultRequestValidationType = "System.Web.Util.RequestValidator";
|
|
internal const string DefaultRequestPathInvalidCharacters = "<,>,*,%,&,:,\\,?";
|
|
internal const int DefaultMaxUrlLength = 260;
|
|
internal const int DefaultMaxQueryStringLength = 2048;
|
|
internal const bool DefaultRelaxedUrlToFileSystemMapping = false;
|
|
internal const string DefaultTargetFramework = null;
|
|
|
|
private AsyncPreloadModeFlags asyncPreloadModeCache;
|
|
private bool asyncPreloadModeCached = false;
|
|
|
|
private bool enableVersionHeaderCache = true;
|
|
private bool enableVersionHeaderCached = false;
|
|
private TimeSpan executionTimeoutCache;
|
|
private bool executionTimeoutCached = false;
|
|
|
|
private bool sendCacheControlHeaderCached = false;
|
|
private bool sendCacheControlHeaderCache;
|
|
|
|
private FcnMode fcnModeCache;
|
|
private bool fcnModeCached = false;
|
|
|
|
private static ConfigurationPropertyCollection _properties;
|
|
private static readonly ConfigurationProperty _propAsyncPreloadMode =
|
|
new ConfigurationProperty("asyncPreloadMode",
|
|
typeof(AsyncPreloadModeFlags),
|
|
AsyncPreloadModeFlags.None,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propExecutionTimeout =
|
|
new ConfigurationProperty("executionTimeout",
|
|
typeof(TimeSpan),
|
|
TimeSpan.FromSeconds((double)DefaultExecutionTimeout),
|
|
StdValidatorsAndConverters.TimeSpanSecondsConverter,
|
|
StdValidatorsAndConverters.PositiveTimeSpanValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propMaxRequestLength =
|
|
new ConfigurationProperty("maxRequestLength",
|
|
typeof(int),
|
|
4096,
|
|
null,
|
|
StdValidatorsAndConverters.NonZeroPositiveIntegerValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propRequestLengthDiskThreshold =
|
|
new ConfigurationProperty("requestLengthDiskThreshold",
|
|
typeof(int),
|
|
80,
|
|
null,
|
|
StdValidatorsAndConverters.NonZeroPositiveIntegerValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propUseFullyQualifiedRedirectUrl =
|
|
new ConfigurationProperty("useFullyQualifiedRedirectUrl",
|
|
typeof(bool),
|
|
false,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propMinFreeThreads =
|
|
new ConfigurationProperty("minFreeThreads",
|
|
typeof(int),
|
|
8,
|
|
null,
|
|
StdValidatorsAndConverters.PositiveIntegerValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propMinLocalRequestFreeThreads =
|
|
new ConfigurationProperty("minLocalRequestFreeThreads",
|
|
typeof(int),
|
|
4,
|
|
null,
|
|
StdValidatorsAndConverters.PositiveIntegerValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propAppRequestQueueLimit =
|
|
new ConfigurationProperty("appRequestQueueLimit",
|
|
typeof(int),
|
|
5000,
|
|
null,
|
|
StdValidatorsAndConverters.NonZeroPositiveIntegerValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propEnableKernelOutputCache =
|
|
new ConfigurationProperty("enableKernelOutputCache",
|
|
typeof(bool),
|
|
true,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propEnableVersionHeader =
|
|
new ConfigurationProperty("enableVersionHeader",
|
|
typeof(bool),
|
|
true,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propRequireRootedSaveAsPath =
|
|
new ConfigurationProperty("requireRootedSaveAsPath",
|
|
typeof(bool),
|
|
true,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propEnable =
|
|
new ConfigurationProperty("enable",
|
|
typeof(bool),
|
|
true,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propDefaultRegexMatchTimeout =
|
|
new ConfigurationProperty("defaultRegexMatchTimeout",
|
|
typeof(TimeSpan),
|
|
TimeSpan.Zero,
|
|
null,
|
|
StdValidatorsAndConverters.RegexMatchTimeoutValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propShutdownTimeout =
|
|
new ConfigurationProperty("shutdownTimeout",
|
|
typeof(TimeSpan),
|
|
TimeSpan.FromSeconds((double)DefaultShutdownTimeout),
|
|
StdValidatorsAndConverters.TimeSpanSecondsConverter,
|
|
null,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propDelayNotificationTimeout =
|
|
new ConfigurationProperty("delayNotificationTimeout",
|
|
typeof(TimeSpan),
|
|
TimeSpan.FromSeconds((double)DefaultDelayNotificationTimeout),
|
|
StdValidatorsAndConverters.TimeSpanSecondsConverter,
|
|
null,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propWaitChangeNotification =
|
|
new ConfigurationProperty("waitChangeNotification",
|
|
typeof(int),
|
|
0,
|
|
null,
|
|
StdValidatorsAndConverters.PositiveIntegerValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propMaxWaitChangeNotification =
|
|
new ConfigurationProperty("maxWaitChangeNotification",
|
|
typeof(int),
|
|
0,
|
|
null,
|
|
StdValidatorsAndConverters.PositiveIntegerValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propEnableHeaderChecking =
|
|
new ConfigurationProperty("enableHeaderChecking",
|
|
typeof(bool),
|
|
true,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propSendCacheControlHeader =
|
|
new ConfigurationProperty("sendCacheControlHeader",
|
|
typeof(bool),
|
|
DefaultSendCacheControlHeader,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propApartmentThreading =
|
|
new ConfigurationProperty("apartmentThreading",
|
|
typeof(bool),
|
|
false,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propEncoderType =
|
|
new ConfigurationProperty("encoderType",
|
|
typeof(string),
|
|
DefaultEncoderType,
|
|
null,
|
|
StdValidatorsAndConverters.NonEmptyStringValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propRequestValidationMode =
|
|
new ConfigurationProperty("requestValidationMode",
|
|
typeof(Version),
|
|
DefaultRequestValidationMode,
|
|
StdValidatorsAndConverters.VersionConverter,
|
|
null,
|
|
ConfigurationPropertyOptions.None);
|
|
private static readonly ConfigurationProperty _propRequestValidationType =
|
|
new ConfigurationProperty("requestValidationType",
|
|
typeof(string),
|
|
DefaultRequestValidationType,
|
|
null,
|
|
StdValidatorsAndConverters.NonEmptyStringValidator,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propRequestPathInvalidCharacters =
|
|
new ConfigurationProperty("requestPathInvalidCharacters",
|
|
typeof(string),
|
|
DefaultRequestPathInvalidCharacters,
|
|
StdValidatorsAndConverters.WhiteSpaceTrimStringConverter,
|
|
null,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propMaxUrlLength =
|
|
new ConfigurationProperty("maxUrlLength",
|
|
typeof(int),
|
|
DefaultMaxUrlLength,
|
|
null,
|
|
new IntegerValidator(0, 2097151), // Max from VS 330766
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propMaxQueryStringLength =
|
|
new ConfigurationProperty("maxQueryStringLength",
|
|
typeof(int),
|
|
DefaultMaxQueryStringLength,
|
|
null,
|
|
new IntegerValidator(0, 2097151), // Max from VS 330766
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propRelaxedUrlToFileSystemMapping =
|
|
new ConfigurationProperty("relaxedUrlToFileSystemMapping",
|
|
typeof(bool),
|
|
DefaultRelaxedUrlToFileSystemMapping,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propAllowDynamicModuleRegistration =
|
|
new ConfigurationProperty("allowDynamicModuleRegistration",
|
|
typeof(bool),
|
|
DefaultAllowDynamicModuleRegistration,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propFcnMode =
|
|
new ConfigurationProperty("fcnMode",
|
|
typeof(FcnMode),
|
|
FcnMode.NotSet,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
private static readonly ConfigurationProperty _propTargetFramework =
|
|
new ConfigurationProperty("targetFramework",
|
|
typeof(string),
|
|
DefaultTargetFramework,
|
|
ConfigurationPropertyOptions.None);
|
|
|
|
|
|
private int _MaxRequestLengthBytes;
|
|
private int _RequestLengthDiskThresholdBytes;
|
|
private static String s_versionHeader = null;
|
|
private Version _requestValidationMode;
|
|
|
|
/* <!--
|
|
httpRuntime Attributes:
|
|
asyncPreloadMode="None" [None | Form | FormMultiPart | AllFormTypes | NonForm | All]
|
|
executionTimeout="[seconds]" - time in seconds before request is automatically timed out
|
|
maxRequestLength="[KBytes]" - KBytes size of maximum request length to accept
|
|
requestLengthDiskThreshold="[KBytes]" - KBytes threshold to use disk for posted content temporary storage
|
|
useFullyQualifiedRedirectUrl="[true|false]" - Fully qualifiy the URL for client redirects
|
|
minFreeThreads="[count]" - minimum number of free thread to allow execution of new requests
|
|
minLocalRequestFreeThreads="[count]" - minimum number of free thread to allow execution of new local requests
|
|
appRequestQueueLimit="[count]" - maximum number of requests queued for the application; the sum of requests in all application queues is bounded from above by the global requestQueueLimit in the processModel section
|
|
enableKernelOutputCache="[true|false]" - enable the http.sys cache on IIS6 and higher - default is true
|
|
enableVersionHeader="[true|false]" - outputs X-AspNet-Version header with each request
|
|
requireRootedSaveAsPath="[true|false]" - the filename argument to SaveAs methods must be a rooted path
|
|
enable="[true|false]" - enable processing requests for this application
|
|
waitChangeNotification="[seconds]" - time in seconds to wait for another file change notification before restarting the AppDomain
|
|
maxWaitChangeNotification="[seconds]" - maximum time in seconds to wait from the first file change notification before restarting the AppDomain
|
|
enableHeaderChecking="[true|false]" - when true, CRLF pairs in response headers are encoded
|
|
encoderType="[typename]" - type used for custom HTTP encoding (HTML encoding, URL encoding, etc.)
|
|
requestValidationMode="[version]" - "2.0" to turn request validation on only for pages, "4.0" for the entire pipeline, "4.5" to enable granular request validation
|
|
requestValidationType="[typename]" - type used for custom request validation
|
|
RequestPathInvalidCharacters="[string]" - comma seperated list of chars in the URL to reject
|
|
maxUrlLength="[int]" - Max length of Request.Path
|
|
maxQueryStringLength="[int]" - Max length of QueryString
|
|
relaxedUrlToFileSystemMapping = "false"
|
|
allowDynamicModuleRegistration="[true|flase]" - used to block RegisterModule method calls
|
|
targetFramework="[string]" - framework version behavior to trigger CLR "quirks mode" settings
|
|
-->
|
|
<httpRuntime
|
|
asyncPreloadMode="None"
|
|
executionTimeout="110"
|
|
maxRequestLength="4096"
|
|
requestLengthDiskThreshold="80"
|
|
useFullyQualifiedRedirectUrl="false"
|
|
minFreeThreads="8"
|
|
minLocalRequestFreeThreads="4"
|
|
appRequestQueueLimit="5000"
|
|
enableVersionHeader="true"
|
|
requireRootedSaveAsPath="true"
|
|
enable="true"
|
|
encoderType="System.Web.Util.HttpEncoder"
|
|
requestValidationMode="4.0"
|
|
requestValidationType="System.Web.Util.RequestValidator"
|
|
RequestPathInvalidCharacters="<,>,*,%,&,:,\,?"
|
|
maxUrlLength="260"
|
|
maxQueryStringLength="4096"
|
|
relaxedUrlToFileSystemMapping = "false"
|
|
allowDynamicModuleRegistration = "true"
|
|
/>
|
|
*/
|
|
|
|
static HttpRuntimeSection() {
|
|
// Property initialization
|
|
_properties = new ConfigurationPropertyCollection();
|
|
_properties.Add(_propAsyncPreloadMode);
|
|
_properties.Add(_propExecutionTimeout);
|
|
_properties.Add(_propMaxRequestLength);
|
|
_properties.Add(_propRequestLengthDiskThreshold);
|
|
_properties.Add(_propUseFullyQualifiedRedirectUrl);
|
|
_properties.Add(_propMinFreeThreads);
|
|
_properties.Add(_propMinLocalRequestFreeThreads);
|
|
_properties.Add(_propAppRequestQueueLimit);
|
|
_properties.Add(_propEnableKernelOutputCache);
|
|
_properties.Add(_propEnableVersionHeader);
|
|
_properties.Add(_propRequireRootedSaveAsPath);
|
|
_properties.Add(_propEnable);
|
|
|
|
_properties.Add(_propDefaultRegexMatchTimeout);
|
|
_properties.Add(_propShutdownTimeout);
|
|
_properties.Add(_propDelayNotificationTimeout);
|
|
_properties.Add(_propWaitChangeNotification);
|
|
_properties.Add(_propMaxWaitChangeNotification);
|
|
|
|
_properties.Add(_propEnableHeaderChecking);
|
|
_properties.Add(_propSendCacheControlHeader);
|
|
_properties.Add(_propApartmentThreading);
|
|
|
|
_properties.Add(_propEncoderType);
|
|
_properties.Add(_propRequestValidationMode);
|
|
_properties.Add(_propRequestValidationType);
|
|
_properties.Add(_propRequestPathInvalidCharacters);
|
|
_properties.Add(_propMaxUrlLength);
|
|
_properties.Add(_propMaxQueryStringLength);
|
|
_properties.Add(_propRelaxedUrlToFileSystemMapping);
|
|
_properties.Add(_propAllowDynamicModuleRegistration);
|
|
_properties.Add(_propFcnMode);
|
|
_properties.Add(_propTargetFramework);
|
|
}
|
|
|
|
public HttpRuntimeSection() {
|
|
_MaxRequestLengthBytes = -1;
|
|
_RequestLengthDiskThresholdBytes = -1;
|
|
}
|
|
|
|
protected override ConfigurationPropertyCollection Properties {
|
|
get {
|
|
return _properties;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("asyncPreloadMode", DefaultValue = AsyncPreloadModeFlags.None)]
|
|
public AsyncPreloadModeFlags AsyncPreloadMode {
|
|
get {
|
|
if (asyncPreloadModeCached == false) {
|
|
asyncPreloadModeCache = (AsyncPreloadModeFlags)base[_propAsyncPreloadMode];
|
|
asyncPreloadModeCached = true;
|
|
}
|
|
return asyncPreloadModeCache;
|
|
}
|
|
set {
|
|
base[_propAsyncPreloadMode] = value;
|
|
asyncPreloadModeCache = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("fcnMode", DefaultValue = FcnMode.NotSet)]
|
|
public FcnMode FcnMode {
|
|
get {
|
|
if (!fcnModeCached) {
|
|
fcnModeCache = (FcnMode)base[_propFcnMode];
|
|
fcnModeCached = true;
|
|
}
|
|
return fcnModeCache;
|
|
}
|
|
set {
|
|
base[_propFcnMode] = value;
|
|
fcnModeCache = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("executionTimeout", DefaultValue = "00:01:50")]
|
|
[TypeConverter(typeof(TimeSpanSecondsConverter))]
|
|
[TimeSpanValidator(MinValueString = "00:00:00", MaxValueString = TimeSpanValidatorAttribute.TimeSpanMaxValue)]
|
|
public TimeSpan ExecutionTimeout {
|
|
get {
|
|
if (executionTimeoutCached == false) {
|
|
executionTimeoutCache = (TimeSpan)base[_propExecutionTimeout];
|
|
executionTimeoutCached = true;
|
|
}
|
|
return executionTimeoutCache;
|
|
}
|
|
set {
|
|
base[_propExecutionTimeout] = value;
|
|
executionTimeoutCache = value;
|
|
}
|
|
|
|
|
|
}
|
|
|
|
[ConfigurationProperty("maxRequestLength", DefaultValue = 4096)]
|
|
[IntegerValidator(MinValue = 0)]
|
|
public int MaxRequestLength {
|
|
get {
|
|
return (int)base[_propMaxRequestLength];
|
|
}
|
|
set {
|
|
if (value < RequestLengthDiskThreshold) {
|
|
throw new ConfigurationErrorsException(SR.GetString(SR.Config_max_request_length_smaller_than_max_request_length_disk_threshold),
|
|
ElementInformation.Properties[_propMaxRequestLength.Name].Source,
|
|
ElementInformation.Properties[_propMaxRequestLength.Name].LineNumber);
|
|
}
|
|
base[_propMaxRequestLength] = value;
|
|
} //
|
|
}
|
|
|
|
[ConfigurationProperty("requestLengthDiskThreshold", DefaultValue = 80)]
|
|
[IntegerValidator(MinValue = 1)]
|
|
public int RequestLengthDiskThreshold {
|
|
get {
|
|
return (int)base[_propRequestLengthDiskThreshold];
|
|
}
|
|
set {
|
|
if (value > MaxRequestLength) {
|
|
throw new ConfigurationErrorsException(SR.GetString(SR.Config_max_request_length_disk_threshold_exceeds_max_request_length),
|
|
ElementInformation.Properties[_propRequestLengthDiskThreshold.Name].Source,
|
|
ElementInformation.Properties[_propRequestLengthDiskThreshold.Name].LineNumber);
|
|
}
|
|
base[_propRequestLengthDiskThreshold] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("useFullyQualifiedRedirectUrl", DefaultValue = false)]
|
|
public bool UseFullyQualifiedRedirectUrl {
|
|
get {
|
|
return (bool)base[_propUseFullyQualifiedRedirectUrl];
|
|
}
|
|
set {
|
|
base[_propUseFullyQualifiedRedirectUrl] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("minFreeThreads", DefaultValue = 8)]
|
|
[IntegerValidator(MinValue = 0)]
|
|
public int MinFreeThreads {
|
|
get {
|
|
return (int)base[_propMinFreeThreads];
|
|
}
|
|
set {
|
|
base[_propMinFreeThreads] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("minLocalRequestFreeThreads", DefaultValue = 4)]
|
|
[IntegerValidator(MinValue = 0)]
|
|
public int MinLocalRequestFreeThreads {
|
|
get {
|
|
return (int)base[_propMinLocalRequestFreeThreads];
|
|
}
|
|
set {
|
|
base[_propMinLocalRequestFreeThreads] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("appRequestQueueLimit", DefaultValue = 5000)]
|
|
[IntegerValidator(MinValue = 1)]
|
|
public int AppRequestQueueLimit {
|
|
get {
|
|
return (int)base[_propAppRequestQueueLimit];
|
|
}
|
|
set {
|
|
base[_propAppRequestQueueLimit] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("enableKernelOutputCache", DefaultValue = true)]
|
|
public bool EnableKernelOutputCache {
|
|
get {
|
|
return (bool)base[_propEnableKernelOutputCache];
|
|
}
|
|
set {
|
|
base[_propEnableKernelOutputCache] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("enableVersionHeader", DefaultValue = true)]
|
|
public bool EnableVersionHeader {
|
|
get {
|
|
if (enableVersionHeaderCached == false) {
|
|
enableVersionHeaderCache = (bool)base[_propEnableVersionHeader];
|
|
enableVersionHeaderCached = true;
|
|
}
|
|
return enableVersionHeaderCache;
|
|
}
|
|
set {
|
|
base[_propEnableVersionHeader] = value;
|
|
enableVersionHeaderCache = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("apartmentThreading", DefaultValue = false)]
|
|
public bool ApartmentThreading {
|
|
get {
|
|
return (bool)base[_propApartmentThreading];
|
|
}
|
|
set {
|
|
base[_propApartmentThreading] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("requireRootedSaveAsPath", DefaultValue = true)]
|
|
public bool RequireRootedSaveAsPath {
|
|
get {
|
|
return (bool)base[_propRequireRootedSaveAsPath];
|
|
}
|
|
set {
|
|
base[_propRequireRootedSaveAsPath] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("enable", DefaultValue = true)]
|
|
public bool Enable {
|
|
get {
|
|
return (bool)base[_propEnable];
|
|
}
|
|
set {
|
|
base[_propEnable] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("targetFramework", DefaultValue = DefaultTargetFramework)]
|
|
public string TargetFramework {
|
|
get {
|
|
return (string)base[_propTargetFramework];
|
|
}
|
|
set {
|
|
base[_propTargetFramework] = value;
|
|
}
|
|
}
|
|
|
|
// method is used to provide a FrameworkName to be used for the AppDomainSetup.TargetFrameworkName property
|
|
internal FrameworkName GetTargetFrameworkName() {
|
|
string targetFramework = TargetFramework; // only read from property once so the value can't change in the middle of processing
|
|
if (String.IsNullOrEmpty(targetFramework)) {
|
|
// no target framework; let caller perform default behavior
|
|
return null;
|
|
}
|
|
else {
|
|
Version version;
|
|
if (!Version.TryParse(targetFramework, out version)) {
|
|
// if this doesn't parse as a valid Version object, throw an exception containing the erroneous line in config
|
|
PropertyInformation targetFrameworkPropInfo = ElementInformation.Properties["targetFramework"];
|
|
throw new ConfigurationErrorsException(SR.GetString(SR.HttpRuntimeSection_TargetFramework_Invalid),
|
|
filename: targetFrameworkPropInfo.Source,
|
|
line: targetFrameworkPropInfo.LineNumber);
|
|
}
|
|
|
|
// check succeeded
|
|
return new FrameworkName(".NETFramework", version);
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("sendCacheControlHeader", DefaultValue = DefaultSendCacheControlHeader)]
|
|
public bool SendCacheControlHeader {
|
|
get {
|
|
if (sendCacheControlHeaderCached == false) {
|
|
sendCacheControlHeaderCache = (bool)base[_propSendCacheControlHeader];
|
|
sendCacheControlHeaderCached = true;
|
|
}
|
|
return sendCacheControlHeaderCache;
|
|
}
|
|
set {
|
|
base[_propSendCacheControlHeader] = value;
|
|
sendCacheControlHeaderCache = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("defaultRegexMatchTimeout", DefaultValue = "00:00:00")]
|
|
[RegexMatchTimeoutValidator]
|
|
public TimeSpan DefaultRegexMatchTimeout {
|
|
get {
|
|
return (TimeSpan)base[_propDefaultRegexMatchTimeout];
|
|
}
|
|
set {
|
|
base[_propDefaultRegexMatchTimeout] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("shutdownTimeout", DefaultValue = "00:01:30")]
|
|
[TypeConverter(typeof(TimeSpanSecondsConverter))]
|
|
public TimeSpan ShutdownTimeout {
|
|
get {
|
|
return (TimeSpan)base[_propShutdownTimeout];
|
|
}
|
|
set {
|
|
base[_propShutdownTimeout] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("delayNotificationTimeout", DefaultValue = "00:00:00")]
|
|
[TypeConverter(typeof(TimeSpanSecondsConverter))]
|
|
public TimeSpan DelayNotificationTimeout {
|
|
get {
|
|
return (TimeSpan)base[_propDelayNotificationTimeout];
|
|
}
|
|
set {
|
|
base[_propDelayNotificationTimeout] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("waitChangeNotification", DefaultValue = 0)]
|
|
[IntegerValidator(MinValue = 0)]
|
|
public int WaitChangeNotification {
|
|
get {
|
|
return (int)base[_propWaitChangeNotification];
|
|
}
|
|
set {
|
|
base[_propWaitChangeNotification] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("maxWaitChangeNotification", DefaultValue = 0)]
|
|
[IntegerValidator(MinValue = 0)]
|
|
public int MaxWaitChangeNotification {
|
|
get {
|
|
return (int)base[_propMaxWaitChangeNotification];
|
|
}
|
|
set {
|
|
base[_propMaxWaitChangeNotification] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("enableHeaderChecking", DefaultValue = true)]
|
|
public bool EnableHeaderChecking {
|
|
get {
|
|
return (bool)base[_propEnableHeaderChecking];
|
|
}
|
|
set {
|
|
base[_propEnableHeaderChecking] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("encoderType", DefaultValue = DefaultEncoderType)]
|
|
[StringValidator(MinLength = 1)]
|
|
public string EncoderType {
|
|
get {
|
|
return (string)base[_propEncoderType];
|
|
}
|
|
set {
|
|
base[_propEncoderType] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("requestValidationMode", DefaultValue = DefaultRequestValidationModeString)]
|
|
[TypeConverter(typeof(VersionConverter))]
|
|
public Version RequestValidationMode {
|
|
get {
|
|
if (_requestValidationMode == null) {
|
|
_requestValidationMode = (Version)base[_propRequestValidationMode];
|
|
}
|
|
return _requestValidationMode;
|
|
}
|
|
set {
|
|
_requestValidationMode = value;
|
|
base[_propRequestValidationMode] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("requestValidationType", DefaultValue = DefaultRequestValidationType)]
|
|
[StringValidator(MinLength = 1)]
|
|
public string RequestValidationType {
|
|
get {
|
|
return (string)base[_propRequestValidationType];
|
|
}
|
|
set {
|
|
base[_propRequestValidationType] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("requestPathInvalidCharacters", DefaultValue = DefaultRequestPathInvalidCharacters)]
|
|
public string RequestPathInvalidCharacters {
|
|
get {
|
|
return (string)base[_propRequestPathInvalidCharacters];
|
|
}
|
|
set {
|
|
base[_propRequestPathInvalidCharacters] = value;
|
|
_RequestPathInvalidCharactersArray = null;
|
|
}
|
|
}
|
|
|
|
private int _MaxUrlLength = 0;
|
|
[ConfigurationProperty("maxUrlLength", DefaultValue = DefaultMaxUrlLength)]
|
|
[IntegerValidator(MinValue = 0)]
|
|
public int MaxUrlLength {
|
|
get {
|
|
if (_MaxUrlLength == 0)
|
|
_MaxUrlLength = (int)base[_propMaxUrlLength];
|
|
return _MaxUrlLength;
|
|
}
|
|
set {
|
|
_MaxUrlLength = value;
|
|
base[_propMaxUrlLength] = value;
|
|
}
|
|
}
|
|
|
|
|
|
private int _MaxQueryStringLength = 0;
|
|
[ConfigurationProperty("maxQueryStringLength", DefaultValue = DefaultMaxQueryStringLength)]
|
|
[IntegerValidator(MinValue = 0)]
|
|
public int MaxQueryStringLength {
|
|
get {
|
|
if (_MaxQueryStringLength == 0)
|
|
_MaxQueryStringLength = (int)base[_propMaxQueryStringLength];
|
|
return _MaxQueryStringLength;
|
|
}
|
|
set {
|
|
_MaxQueryStringLength = value;
|
|
base[_propMaxQueryStringLength] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("relaxedUrlToFileSystemMapping", DefaultValue = DefaultRelaxedUrlToFileSystemMapping)]
|
|
public bool RelaxedUrlToFileSystemMapping {
|
|
get {
|
|
return (bool)base[_propRelaxedUrlToFileSystemMapping];
|
|
}
|
|
set {
|
|
base[_propRelaxedUrlToFileSystemMapping] = value;
|
|
}
|
|
}
|
|
|
|
[ConfigurationProperty("allowDynamicModuleRegistration", DefaultValue = DefaultAllowDynamicModuleRegistration)]
|
|
public bool AllowDynamicModuleRegistration {
|
|
get {
|
|
return (bool)base[_propAllowDynamicModuleRegistration];
|
|
}
|
|
set {
|
|
base[_propAllowDynamicModuleRegistration] = value;
|
|
}
|
|
}
|
|
|
|
private int BytesFromKilobytes(int kilobytes) {
|
|
long maxLength = kilobytes * 1024L;
|
|
return ((maxLength < Int32.MaxValue) ? (int)maxLength : Int32.MaxValue);
|
|
}
|
|
|
|
internal int MaxRequestLengthBytes {
|
|
get {
|
|
if (_MaxRequestLengthBytes < 0) {
|
|
_MaxRequestLengthBytes = BytesFromKilobytes(MaxRequestLength);
|
|
}
|
|
return _MaxRequestLengthBytes;
|
|
}
|
|
}
|
|
|
|
internal int RequestLengthDiskThresholdBytes {
|
|
get {
|
|
if (_RequestLengthDiskThresholdBytes < 0) {
|
|
_RequestLengthDiskThresholdBytes = BytesFromKilobytes(RequestLengthDiskThreshold);
|
|
}
|
|
return _RequestLengthDiskThresholdBytes;
|
|
}
|
|
}
|
|
|
|
internal String VersionHeader {
|
|
get {
|
|
if (!EnableVersionHeader) {
|
|
return null;
|
|
}
|
|
|
|
if (s_versionHeader == null) {
|
|
String header = null;
|
|
// construct once (race condition here doesn't matter)
|
|
try {
|
|
String version = VersionInfo.SystemWebVersion;
|
|
int i = version.LastIndexOf('.');
|
|
if (i > 0) {
|
|
header = version.Substring(0, i);
|
|
}
|
|
}
|
|
catch {
|
|
}
|
|
|
|
if (header == null) {
|
|
header = String.Empty;
|
|
}
|
|
|
|
s_versionHeader = header;
|
|
}
|
|
|
|
return s_versionHeader;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////
|
|
private char[] _RequestPathInvalidCharactersArray = null;
|
|
internal char[] RequestPathInvalidCharactersArray {
|
|
get {
|
|
if (_RequestPathInvalidCharactersArray != null)
|
|
return _RequestPathInvalidCharactersArray;
|
|
|
|
_RequestPathInvalidCharactersArray = DecodeAndThenSplitString(RequestPathInvalidCharacters);
|
|
if (_RequestPathInvalidCharactersArray == null) {
|
|
// Maybe comma was one of the invalid chars, which can cause DecodeAndThenSplitString to fail
|
|
// Split using the comma and then decode each part
|
|
_RequestPathInvalidCharactersArray = SplitStringAndThenDecode(RequestPathInvalidCharacters);
|
|
}
|
|
|
|
if (_RequestPathInvalidCharactersArray == null) { // failed to construct invalid chars
|
|
throw new ConfigurationErrorsException(SR.GetString(SR.Config_property_generic),
|
|
ElementInformation.Properties[_propRequestPathInvalidCharacters.Name].Source,
|
|
ElementInformation.Properties[_propRequestPathInvalidCharacters.Name].LineNumber);
|
|
}
|
|
return _RequestPathInvalidCharactersArray;
|
|
}
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////
|
|
private static char[] DecodeAndThenSplitString(string invalidCharString) {
|
|
if (string.IsNullOrEmpty(invalidCharString)) {
|
|
return new char[0];
|
|
}
|
|
|
|
string[] stringsDecoded = HttpUtility.UrlDecode(invalidCharString, Encoding.UTF8).Split(',');
|
|
char[] charsDecoded = new char[stringsDecoded.Length];
|
|
|
|
for (int iter = 0; iter < stringsDecoded.Length; iter++) {
|
|
string decodedString = stringsDecoded[iter].Trim();
|
|
if (decodedString.Length == 1)
|
|
charsDecoded[iter] = decodedString[0];
|
|
else
|
|
return null; // failed
|
|
}
|
|
return charsDecoded;
|
|
}
|
|
|
|
//////////////////////////////////////////////////////////////////
|
|
//////////////////////////////////////////////////////////////////
|
|
private static char[] SplitStringAndThenDecode(string invalidCharString) {
|
|
if (string.IsNullOrEmpty(invalidCharString)) {
|
|
return new char[0];
|
|
}
|
|
|
|
string[] stringsToDecode = invalidCharString.Split(',');
|
|
char[] charsDecoded = new char[stringsToDecode.Length];
|
|
|
|
for (int iter = 0; iter < stringsToDecode.Length; iter++) {
|
|
string decodedString = HttpUtility.UrlDecode(stringsToDecode[iter], Encoding.UTF8).Trim();
|
|
if (decodedString.Length == 1)
|
|
charsDecoded[iter] = decodedString[0];
|
|
else
|
|
return null; // failed
|
|
}
|
|
return charsDecoded;
|
|
}
|
|
|
|
// This is called as the last step of the deserialization process before the newly created section is seen by the consumer.
|
|
// We can use it to change defaults on-the-fly.
|
|
protected override void SetReadOnly() {
|
|
// Unless overridden, set <httpRuntime requestValidationMode="4.5" />
|
|
ConfigUtil.SetFX45DefaultValue(this, _propRequestValidationMode, VersionUtil.Framework45);
|
|
|
|
base.SetReadOnly();
|
|
}
|
|
}
|
|
}
|