Code:
/ 4.0 / 4.0 / DEVDIV_TFS / Dev10 / Releases / RTMRel / ndp / fx / src / xsp / System / Web / CachedPathData.cs / 1605387 / CachedPathData.cs
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web {
using System.Collections;
using System.Configuration;
using System.Configuration.Internal;
using System.Globalization;
using System.Security.Principal;
using System.Threading;
using System.Web.Security;
using System.Web.SessionState;
using System.Web.Configuration;
using System.Web.Caching;
using System.Web.Hosting;
using System.Web.Util;
using System.Web.UI;
using System.Security.Permissions;
// Data about a path that is cached across requests
class CachedPathData {
internal const int FInited = 0x0001;
internal const int FCompletedFirstRequest = 0x0002;
internal const int FExists = 0x0004;
internal const int FOwnsConfigRecord = 0x0010; // is this the highest ancestor pointing to the config record?
internal const int FClosed = 0x0020; // Has item been closed already?
internal const int FCloseNeeded = 0x0040; // Should we close?
internal const int FAnonymousAccessChecked = 0x0100;
internal const int FAnonymousAccessAllowed = 0x0200;
static CacheItemRemovedCallback s_callback = new CacheItemRemovedCallback(CachedPathData.OnCacheItemRemoved);
// initialize the URL metadata cache expiration here, just in case there's an issue with HttpRuntime.HostingInit
private static TimeSpan s_urlMetadataSlidingExpiration = HostingEnvironmentSection.DefaultUrlMetadataSlidingExpiration;
private static bool s_doNotCacheUrlMetadata = false;
private static int s_appConfigPathLength = 0;
#pragma warning disable 0649
SafeBitVector32 _flags;
#pragma warning restore 0649
string _configPath;
VirtualPath _virtualPath;
string _physicalPath;
RuntimeConfig _runtimeConfig;
HandlerMappingMemo _handlerMemo;
//
// Constructor
//
internal CachedPathData(string configPath, VirtualPath virtualPath, string physicalPath, bool exists) {
// Guarantee that we return a non-null config record
// if an error occurs during initialization.
_runtimeConfig = RuntimeConfig.GetErrorRuntimeConfig();
_configPath = configPath;
_virtualPath = virtualPath;
_physicalPath = physicalPath;
_flags[FExists] = exists;
// VSWhidbey 607683: Config loading for web app has a dependency on CachedPathData.
// On the other hand, Config also has a dependency on Uri class which has
// a new static constructor that calls config, and eventually to CachedPathData again.
// We need a dummy reference to Uri class so the static constructor would be involved
// first to initialize config.
string dummy = System.Uri.SchemeDelimiter;
}
//
// Called by HttpRuntime.HostingInit to initialize UrlMetadataSlidingExpiration
//
static internal void InitializeUrlMetadataSlidingExpiration(HostingEnvironmentSection section) {
TimeSpan slidingExp = section.UrlMetadataSlidingExpiration;
if (slidingExp == TimeSpan.Zero) {
// a value of TimeSpan.Zero means don't cache
// this "feature" was added for Bing, because they
// have scenarios where the same URL is never seen twice
s_doNotCacheUrlMetadata = true;
}
else if (slidingExp == TimeSpan.MaxValue) {
// a value of TimeSpan.MaxValue means use Cache.NoSlidingExpiration,
// which is how CachedPathData used to be cached, so this effectively
// reverts to v2.0 behavior for caching CachedPathData
s_urlMetadataSlidingExpiration = Cache.NoSlidingExpiration;
s_doNotCacheUrlMetadata = false;
}
else {
// anything in between means cache with that sliding expiration
s_urlMetadataSlidingExpiration = slidingExp;
s_doNotCacheUrlMetadata = false;
}
}
//
// Get CachedPathData for the machine.config level
//
static internal CachedPathData GetMachinePathData() {
return GetConfigPathData(WebConfigurationHost.MachineConfigPath);
}
//
// Get CachedPathData for the root web.config path
//
static internal CachedPathData GetRootWebPathData() {
return GetConfigPathData(WebConfigurationHost.RootWebConfigPath);
}
//
// Get CachedPathData for the application.
//
static internal CachedPathData GetApplicationPathData() {
if (!HostingEnvironment.IsHosted) {
return GetRootWebPathData();
}
return GetConfigPathData(HostingEnvironment.AppConfigPath);
}
//
// Get CachedPathData for a virtual path.
// The path may be supplied by user code, so check that it is valid.
//
static internal CachedPathData GetVirtualPathData(VirtualPath virtualPath, bool permitPathsOutsideApp) {
if (!HostingEnvironment.IsHosted) {
return GetRootWebPathData();
}
// Make sure it's not relative
if (virtualPath != null) {
virtualPath.FailIfRelativePath();
}
// Check if the path is within the application.
if (virtualPath == null || !virtualPath.IsWithinAppRoot) {
if (permitPathsOutsideApp) {
return GetApplicationPathData();
}
else {
throw new ArgumentException(SR.GetString(
SR.Cross_app_not_allowed,
(virtualPath != null) ? virtualPath.VirtualPathString : "null"));
}
}
// Construct a configPath based on the unvalidated virtualPath.
string configPath = WebConfigurationHost.GetConfigPathFromSiteIDAndVPath(HostingEnvironment.SiteID, virtualPath);
// Pass the virtualPath to GetConfigPathData to validate in the case where the
// CachedPathData for the unsafeConfigPath is not found.
return GetConfigPathData(configPath);
}
// Dev10 862204: AppDomain does not restart when the application's web.config is touched 2 minutes after the last request
static private bool IsCachedPathDataRemovable(string configPath) {
// have we initialized yet?
if (s_appConfigPathLength == 0) {
// when hosted use AppConfigPath, otherwise use RootWebConfigPath
s_appConfigPathLength = (HostingEnvironment.IsHosted) ? HostingEnvironment.AppConfigPath.Length : WebConfigurationHost.RootWebConfigPath.Length;
}
// Only config paths beneath the application config path can be removed from the cache.
return (configPath.Length > s_appConfigPathLength);
}
// Example of configPath = "machine/webroot/1/fxtest/sub/foo.aspx"
// The configPath parameter must be lower case.
static private CachedPathData GetConfigPathData(string configPath) {
Debug.Assert(ConfigPathUtility.IsValid(configPath), "ConfigPathUtility.IsValid(configPath)");
Debug.Assert(configPath == configPath.ToLower(CultureInfo.InvariantCulture), "configPath == configPath.ToLower(CultureInfo.InvariantCulture)");
bool exists = false;
bool isDirectory = false;
bool isRemovable = IsCachedPathDataRemovable(configPath);
// if the sliding expiration is zero, we won't cache it unless it is a configPath for root web.config or above
if (isRemovable && DoNotCacheUrlMetadata) {
string pathSiteID = null;
VirtualPath virtualFilePath = null;
string physicalFilePath = null;
WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPath, out pathSiteID, out virtualFilePath);
physicalFilePath = GetPhysicalPath(virtualFilePath);
string parentConfigPath = ConfigPathUtility.GetParent(configPath);
CachedPathData pathParentData = GetConfigPathData(parentConfigPath);
if (!String.IsNullOrEmpty(physicalFilePath)) {
FileUtil.PhysicalPathStatus(physicalFilePath, false, false, out exists, out isDirectory);
}
CachedPathData pathData = new CachedPathData(configPath, virtualFilePath, physicalFilePath, exists);
pathData.Init(pathParentData);
return pathData;
}
//
// First, see if the CachedPathData is in the cache.
// we don't use Add for this lookup, as doing so requires
// creating a CacheDependency, which can be slow as it may hit
// the filesystem.
//
string key = CreateKey(configPath);
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
CachedPathData data = (CachedPathData) cacheInternal.Get(key);
// if found, return the data
if (data != null) {
data.WaitForInit();
return data;
}
// WOS
bool cacheEntryIsNotRemovable = false;
// if not found, try to add it
string siteID = null;
VirtualPath virtualPath = null;
CachedPathData parentData = null;
CacheDependency dependency = null;
string physicalPath = null;
string[] fileDependencies = null;
string[] cacheItemDependencies = null;
if (WebConfigurationHost.IsMachineConfigPath(configPath)) {
cacheEntryIsNotRemovable = true;
}
else {
// Make sure we have the parent data so we can create a dependency on the parent.
// The parent dependency will ensure that configuration data in the parent
// will be referenced by a cache hit on the child. (see UtcUpdateUsageRecursive in Cache.cs)
string parentConfigPath = ConfigPathUtility.GetParent(configPath);
parentData = GetConfigPathData(parentConfigPath);
string parentKey = CreateKey(parentConfigPath);
cacheItemDependencies = new string[1] {parentKey};
if (!WebConfigurationHost.IsVirtualPathConfigPath(configPath)) {
// assume hardcoded levels above the path, such as root web.config, exist
cacheEntryIsNotRemovable = true;
}
else {
cacheEntryIsNotRemovable = !isRemovable;
WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPath, out siteID, out virtualPath);
physicalPath = GetPhysicalPath(virtualPath);
// Add a dependency on the path itself, if it is a file,
// to handle the case where a file is deleted and replaced
// with a directory of the same name.
if (!String.IsNullOrEmpty(physicalPath)) {
FileUtil.PhysicalPathStatus(physicalPath, false, false, out exists, out isDirectory);
if (exists && !isDirectory) {
fileDependencies = new string[1] {physicalPath};
}
}
}
try {
dependency = new CacheDependency(0, fileDependencies, cacheItemDependencies);
}
catch {
// CacheDependency ctor could fail because of bogus file path
// and it is ok not to watch those
}
}
// Try to add the CachedPathData to the cache.
CachedPathData dataAdd = null;
bool isDataCreator = false;
bool initCompleted = false;
CacheItemPriority priority = cacheEntryIsNotRemovable ? CacheItemPriority.NotRemovable : CacheItemPriority.Normal;
TimeSpan slidingExpiration = cacheEntryIsNotRemovable ? Cache.NoSlidingExpiration : UrlMetadataSlidingExpiration;
try {
using (dependency) {
dataAdd = new CachedPathData(configPath, virtualPath, physicalPath, exists);
try {
}
finally {
data = (CachedPathData) cacheInternal.UtcAdd(key, dataAdd, dependency,
Cache.NoAbsoluteExpiration, slidingExpiration,
priority, s_callback);
if (data == null) {
isDataCreator = true;
}
}
}
// If another thread added it first, return the data
if (!isDataCreator) {
data.WaitForInit();
return data;
}
// This thread is the creator of the CachedPathData, initialize it
lock (dataAdd) {
try {
dataAdd.Init(parentData);
initCompleted = true;
}
finally {
// free waiters
dataAdd._flags[FInited] = true;
// Wake up waiters.
Monitor.PulseAll(dataAdd);
if (dataAdd._flags[FCloseNeeded]) {
// If we have received a call back to close, then lets
// make sure that our config object is cleaned up
dataAdd.Close();
}
}
}
}
finally {
// All the work in this finally block is for the case where we're the
// creator of the CachedPathData.
if (isDataCreator) {
//
if (!dataAdd._flags[FInited]) {
lock (dataAdd) {
// free waiters
dataAdd._flags[FInited] = true;
// Wake up waiters.
Monitor.PulseAll(dataAdd);
if (dataAdd._flags[FCloseNeeded]) {
// If we have received a call back to close, then lets
// make sure that our config object is cleaned up
dataAdd.Close();
}
}
}
//
// Even though there is a try/catch handler surrounding the call to Init,
// a ThreadAbortException can still cause the handler to be bypassed.
//
// If there is an error, either a thread abort or an error in the config
// file itself, we do want to leave the item cached for a short period
// so that we do not revisit the error and potentially reparse the config file
// on every request.
//
// The reason we simply do not leave the item in the cache forever is that the
// problem that caused the configuration exception may be fixed without touching
// the config file in a way that causes a file change notification (for example, an
// acl change in a parent directory, or a change of path mapping in the metabase).
//
// NOTE: It is important to reinsert the item into the cache AFTER dropping
// the lock on dataAdd, in order to prevent the possibility of deadlock.
//
Debug.Assert(dataAdd._flags[FInited], "_flags[FInited]");
if (!initCompleted || (dataAdd.ConfigRecord != null && dataAdd.ConfigRecord.HasInitErrors)) {
//
// Create a new dependency object as the old one cannot be reused.
// Do not include a file dependency if initialization could not be completed,
// as invoking the file system could lead to further errors during a thread abort.
//
if (dependency != null) {
if (!initCompleted) {
dependency = new CacheDependency(0, null, cacheItemDependencies);
}
else {
dependency = new CacheDependency(0, fileDependencies, cacheItemDependencies);
}
}
using (dependency) {
cacheInternal.UtcInsert(key, dataAdd, dependency,
DateTime.UtcNow.AddSeconds(5), Cache.NoSlidingExpiration,
CacheItemPriority.Normal, s_callback);
}
}
}
}
return dataAdd;
}
// Ensure that the physical path does not look suspicious (MSRC 5556).
static private string GetPhysicalPath(VirtualPath virtualPath) {
string physicalPath = null;
try {
physicalPath = virtualPath.MapPathInternal(true);
}
catch (HttpException e) {
//
// Treat exceptions that are thrown because the path is suspicious
// as "404 Not Found" exceptions. Implementations of MapPath
// will throw HttpException with no error code if the path is
// suspicious.
//
if (e.GetHttpCode() == 500) {
throw new HttpException(404, String.Empty);
}
else {
throw;
}
}
//
// Throw "404 Not Found" if the path is suspicious and
// the implementation of MapPath has not already done so.
//
FileUtil.CheckSuspiciousPhysicalPath(physicalPath);
return physicalPath;
}
// Remove CachedPathData when the first request for the path results in a
// 400 range error. We need to remove all data up the path to account for
// virtual files.
// An example of a 400 range error is "path not found".
static internal void RemoveBadPathData(CachedPathData pathData) {
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
string configPath = pathData._configPath;
string key = CreateKey(configPath);
while (pathData != null && !pathData.CompletedFirstRequest && !pathData.Exists) {
cacheInternal.Remove(key);
configPath = ConfigPathUtility.GetParent(configPath);
if (configPath == null)
break;
key = CreateKey(configPath);
pathData = (CachedPathData) cacheInternal.Get(key);
}
}
// Mark CachedPathData as completed when the first request for the path results in a
// status outside the 400 range. We need to mark all data up the path to account for
// virtual files.
static internal void MarkCompleted(CachedPathData pathData) {
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
string configPath = pathData._configPath;
do {
pathData.CompletedFirstRequest = true;
configPath = ConfigPathUtility.GetParent(configPath);
if (configPath == null)
break;
string key = CreateKey(configPath);
pathData = (CachedPathData) cacheInternal.Get(key);
} while (pathData != null && !pathData.CompletedFirstRequest);
}
// Close
//
// Close the object. This does not mean it can not be used anymore,
// it just means that the cleanup as been done, so we don't have
// to worry about closing it anymore
//
void Close() {
// Only close if we are propertly initialized
if (_flags[FInited]) {
// Only close if we haven't already closed
if (_flags.ChangeValue(FClosed, true)) {
// Remove the config record if we own it
// N.B. ConfigRecord.Remove is safe to call more than once.
if (_flags[FOwnsConfigRecord]) {
ConfigRecord.Remove();
}
}
}
}
// OnCacheItemRemoved
//
// Notification the items has been removed from the cache. Flag
// the item to be cleaned up, and then try cleanup
//
static void OnCacheItemRemoved(string key, object value, CacheItemRemovedReason reason) {
CachedPathData data = (CachedPathData) value;
data._flags[FCloseNeeded] = true;
data.Close();
}
static string CreateKey(string configPath) {
Debug.Assert(configPath == configPath.ToLower(CultureInfo.InvariantCulture), "configPath == configPath.ToLower(CultureInfo.InvariantCulture)");
return CacheInternal.PrefixPathData + configPath;
}
// Initialize the data
void Init(CachedPathData parentData) {
// Note that _runtimeConfig will be set to the singleton instance of ErrorRuntimeConfig
// if a ThreadAbortException is thrown during this method.
Debug.Assert(_runtimeConfig == RuntimeConfig.GetErrorRuntimeConfig(), "_runtimeConfig == RuntimeConfig.GetErrorRuntimeConfig()");
if (!HttpConfigurationSystem.UseHttpConfigurationSystem) {
//
// configRecord may legitimately be null if we are not using the HttpConfigurationSystem.
//
_runtimeConfig = null;
}
else {
IInternalConfigRecord configRecord = HttpConfigurationSystem.GetUniqueConfigRecord(_configPath);
Debug.Assert(configRecord != null, "configRecord != null");
if (configRecord.ConfigPath.Length == _configPath.Length) {
//
// The config is unique to this path, so this make this record the owner of the config.
//
_flags[FOwnsConfigRecord] = true;
_runtimeConfig = new RuntimeConfig(configRecord);
}
else {
//
// The config record is the same as an ancestor's, so use the parent's RuntimeConfig.
//
Debug.Assert(parentData != null, "parentData != null");
_runtimeConfig = parentData._runtimeConfig;
}
}
}
void WaitForInit() {
// Wait for the data to be initialized.
if (!_flags[FInited]) {
lock (this) {
if (!_flags[FInited]) {
Monitor.Wait(this);
}
}
}
}
// Ensure that Request.PhysicalPath is valid (canonical, not too long, and contains valid characters).
// The work is done by CheckSuspiciousPhysicalPath, but as a perf optimization, we can compare
// Request.PhysicalPath with the cached path result. The cached path result is validated before
// it is cached. As long as the cached path result is identical to Request.PhysicalPath, we don't
// have to call CheckSuspiciousPhysicalPath again.
internal void ValidatePath(String physicalPath) {
if (String.IsNullOrEmpty(_physicalPath) && String.IsNullOrEmpty(physicalPath)) {
return;
}
if (!String.IsNullOrEmpty(_physicalPath) && !String.IsNullOrEmpty(physicalPath)) {
if (_physicalPath.Length == physicalPath.Length) {
// if identical, we don't have to call CheckSuspiciousPhysicalPath
if (0 == String.Compare(_physicalPath, 0, physicalPath, 0, physicalPath.Length, StringComparison.OrdinalIgnoreCase)) {
return;
}
}
else if (_physicalPath.Length - physicalPath.Length == 1) {
// if they differ by a trailing slash, we shouldn't call CheckSuspiciousPhysicalPath again
if (_physicalPath[_physicalPath.Length-1] == System.IO.Path.DirectorySeparatorChar
&& (0 == String.Compare(_physicalPath, 0, physicalPath, 0, physicalPath.Length, StringComparison.OrdinalIgnoreCase))) {
return;
}
}
else if (physicalPath.Length - _physicalPath.Length == 1) {
// if they differ by a trailing slash, we shouldn't call CheckSuspiciousPhysicalPath again
if (physicalPath[physicalPath.Length-1] == System.IO.Path.DirectorySeparatorChar
&& (0 == String.Compare(_physicalPath, 0, physicalPath, 0, _physicalPath.Length, StringComparison.OrdinalIgnoreCase))) {
return;
}
}
}
// If we're here, the paths were different, which normally should not happen.
Debug.Assert(false, "ValidatePath optimization failed: Request.PhysicalPath="
+ physicalPath + "; _physicalPath=" + _physicalPath);
FileUtil.CheckSuspiciousPhysicalPath(physicalPath);
}
internal bool CompletedFirstRequest {
get {return _flags[FCompletedFirstRequest];}
set {
_flags[FCompletedFirstRequest] = value;
}
}
internal VirtualPath Path {
get {return _virtualPath;}
}
internal string PhysicalPath {
get { return _physicalPath; }
}
internal bool AnonymousAccessChecked {
get { return _flags[FAnonymousAccessChecked]; }
set { _flags[FAnonymousAccessChecked] = value; }
}
internal bool AnonymousAccessAllowed {
get { return _flags[FAnonymousAccessAllowed]; }
set { _flags[FAnonymousAccessAllowed] = value; }
}
internal bool Exists {
get {return _flags[FExists];}
}
internal HandlerMappingMemo CachedHandler {
get {return _handlerMemo;}
set {_handlerMemo = value;}
}
internal IInternalConfigRecord ConfigRecord {
get {
// _runtimeConfig may be null if we are not using the HttpConfigurationSystem.
return (_runtimeConfig != null) ? _runtimeConfig.ConfigRecord : null;
}
}
internal RuntimeConfig RuntimeConfig {
get {
return _runtimeConfig;
}
}
// Any time we cache metadata for the URL, we should use this
// sliding expiration, unless DoNotCacheUrlMetadata is true.
// This is currently used by CachedPathData, MapPathBasedVirtualPathProvider,
// and FileAuthorizationModule
internal static TimeSpan UrlMetadataSlidingExpiration {
get {
return s_urlMetadataSlidingExpiration;
}
}
// if true, do not cache at all.
internal static bool DoNotCacheUrlMetadata {
get { return s_doNotCacheUrlMetadata; }
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
//------------------------------------------------------------------------------
//
// Copyright (c) Microsoft Corporation. All rights reserved.
//
//-----------------------------------------------------------------------------
namespace System.Web {
using System.Collections;
using System.Configuration;
using System.Configuration.Internal;
using System.Globalization;
using System.Security.Principal;
using System.Threading;
using System.Web.Security;
using System.Web.SessionState;
using System.Web.Configuration;
using System.Web.Caching;
using System.Web.Hosting;
using System.Web.Util;
using System.Web.UI;
using System.Security.Permissions;
// Data about a path that is cached across requests
class CachedPathData {
internal const int FInited = 0x0001;
internal const int FCompletedFirstRequest = 0x0002;
internal const int FExists = 0x0004;
internal const int FOwnsConfigRecord = 0x0010; // is this the highest ancestor pointing to the config record?
internal const int FClosed = 0x0020; // Has item been closed already?
internal const int FCloseNeeded = 0x0040; // Should we close?
internal const int FAnonymousAccessChecked = 0x0100;
internal const int FAnonymousAccessAllowed = 0x0200;
static CacheItemRemovedCallback s_callback = new CacheItemRemovedCallback(CachedPathData.OnCacheItemRemoved);
// initialize the URL metadata cache expiration here, just in case there's an issue with HttpRuntime.HostingInit
private static TimeSpan s_urlMetadataSlidingExpiration = HostingEnvironmentSection.DefaultUrlMetadataSlidingExpiration;
private static bool s_doNotCacheUrlMetadata = false;
private static int s_appConfigPathLength = 0;
#pragma warning disable 0649
SafeBitVector32 _flags;
#pragma warning restore 0649
string _configPath;
VirtualPath _virtualPath;
string _physicalPath;
RuntimeConfig _runtimeConfig;
HandlerMappingMemo _handlerMemo;
//
// Constructor
//
internal CachedPathData(string configPath, VirtualPath virtualPath, string physicalPath, bool exists) {
// Guarantee that we return a non-null config record
// if an error occurs during initialization.
_runtimeConfig = RuntimeConfig.GetErrorRuntimeConfig();
_configPath = configPath;
_virtualPath = virtualPath;
_physicalPath = physicalPath;
_flags[FExists] = exists;
// VSWhidbey 607683: Config loading for web app has a dependency on CachedPathData.
// On the other hand, Config also has a dependency on Uri class which has
// a new static constructor that calls config, and eventually to CachedPathData again.
// We need a dummy reference to Uri class so the static constructor would be involved
// first to initialize config.
string dummy = System.Uri.SchemeDelimiter;
}
//
// Called by HttpRuntime.HostingInit to initialize UrlMetadataSlidingExpiration
//
static internal void InitializeUrlMetadataSlidingExpiration(HostingEnvironmentSection section) {
TimeSpan slidingExp = section.UrlMetadataSlidingExpiration;
if (slidingExp == TimeSpan.Zero) {
// a value of TimeSpan.Zero means don't cache
// this "feature" was added for Bing, because they
// have scenarios where the same URL is never seen twice
s_doNotCacheUrlMetadata = true;
}
else if (slidingExp == TimeSpan.MaxValue) {
// a value of TimeSpan.MaxValue means use Cache.NoSlidingExpiration,
// which is how CachedPathData used to be cached, so this effectively
// reverts to v2.0 behavior for caching CachedPathData
s_urlMetadataSlidingExpiration = Cache.NoSlidingExpiration;
s_doNotCacheUrlMetadata = false;
}
else {
// anything in between means cache with that sliding expiration
s_urlMetadataSlidingExpiration = slidingExp;
s_doNotCacheUrlMetadata = false;
}
}
//
// Get CachedPathData for the machine.config level
//
static internal CachedPathData GetMachinePathData() {
return GetConfigPathData(WebConfigurationHost.MachineConfigPath);
}
//
// Get CachedPathData for the root web.config path
//
static internal CachedPathData GetRootWebPathData() {
return GetConfigPathData(WebConfigurationHost.RootWebConfigPath);
}
//
// Get CachedPathData for the application.
//
static internal CachedPathData GetApplicationPathData() {
if (!HostingEnvironment.IsHosted) {
return GetRootWebPathData();
}
return GetConfigPathData(HostingEnvironment.AppConfigPath);
}
//
// Get CachedPathData for a virtual path.
// The path may be supplied by user code, so check that it is valid.
//
static internal CachedPathData GetVirtualPathData(VirtualPath virtualPath, bool permitPathsOutsideApp) {
if (!HostingEnvironment.IsHosted) {
return GetRootWebPathData();
}
// Make sure it's not relative
if (virtualPath != null) {
virtualPath.FailIfRelativePath();
}
// Check if the path is within the application.
if (virtualPath == null || !virtualPath.IsWithinAppRoot) {
if (permitPathsOutsideApp) {
return GetApplicationPathData();
}
else {
throw new ArgumentException(SR.GetString(
SR.Cross_app_not_allowed,
(virtualPath != null) ? virtualPath.VirtualPathString : "null"));
}
}
// Construct a configPath based on the unvalidated virtualPath.
string configPath = WebConfigurationHost.GetConfigPathFromSiteIDAndVPath(HostingEnvironment.SiteID, virtualPath);
// Pass the virtualPath to GetConfigPathData to validate in the case where the
// CachedPathData for the unsafeConfigPath is not found.
return GetConfigPathData(configPath);
}
// Dev10 862204: AppDomain does not restart when the application's web.config is touched 2 minutes after the last request
static private bool IsCachedPathDataRemovable(string configPath) {
// have we initialized yet?
if (s_appConfigPathLength == 0) {
// when hosted use AppConfigPath, otherwise use RootWebConfigPath
s_appConfigPathLength = (HostingEnvironment.IsHosted) ? HostingEnvironment.AppConfigPath.Length : WebConfigurationHost.RootWebConfigPath.Length;
}
// Only config paths beneath the application config path can be removed from the cache.
return (configPath.Length > s_appConfigPathLength);
}
// Example of configPath = "machine/webroot/1/fxtest/sub/foo.aspx"
// The configPath parameter must be lower case.
static private CachedPathData GetConfigPathData(string configPath) {
Debug.Assert(ConfigPathUtility.IsValid(configPath), "ConfigPathUtility.IsValid(configPath)");
Debug.Assert(configPath == configPath.ToLower(CultureInfo.InvariantCulture), "configPath == configPath.ToLower(CultureInfo.InvariantCulture)");
bool exists = false;
bool isDirectory = false;
bool isRemovable = IsCachedPathDataRemovable(configPath);
// if the sliding expiration is zero, we won't cache it unless it is a configPath for root web.config or above
if (isRemovable && DoNotCacheUrlMetadata) {
string pathSiteID = null;
VirtualPath virtualFilePath = null;
string physicalFilePath = null;
WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPath, out pathSiteID, out virtualFilePath);
physicalFilePath = GetPhysicalPath(virtualFilePath);
string parentConfigPath = ConfigPathUtility.GetParent(configPath);
CachedPathData pathParentData = GetConfigPathData(parentConfigPath);
if (!String.IsNullOrEmpty(physicalFilePath)) {
FileUtil.PhysicalPathStatus(physicalFilePath, false, false, out exists, out isDirectory);
}
CachedPathData pathData = new CachedPathData(configPath, virtualFilePath, physicalFilePath, exists);
pathData.Init(pathParentData);
return pathData;
}
//
// First, see if the CachedPathData is in the cache.
// we don't use Add for this lookup, as doing so requires
// creating a CacheDependency, which can be slow as it may hit
// the filesystem.
//
string key = CreateKey(configPath);
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
CachedPathData data = (CachedPathData) cacheInternal.Get(key);
// if found, return the data
if (data != null) {
data.WaitForInit();
return data;
}
// WOS
bool cacheEntryIsNotRemovable = false;
// if not found, try to add it
string siteID = null;
VirtualPath virtualPath = null;
CachedPathData parentData = null;
CacheDependency dependency = null;
string physicalPath = null;
string[] fileDependencies = null;
string[] cacheItemDependencies = null;
if (WebConfigurationHost.IsMachineConfigPath(configPath)) {
cacheEntryIsNotRemovable = true;
}
else {
// Make sure we have the parent data so we can create a dependency on the parent.
// The parent dependency will ensure that configuration data in the parent
// will be referenced by a cache hit on the child. (see UtcUpdateUsageRecursive in Cache.cs)
string parentConfigPath = ConfigPathUtility.GetParent(configPath);
parentData = GetConfigPathData(parentConfigPath);
string parentKey = CreateKey(parentConfigPath);
cacheItemDependencies = new string[1] {parentKey};
if (!WebConfigurationHost.IsVirtualPathConfigPath(configPath)) {
// assume hardcoded levels above the path, such as root web.config, exist
cacheEntryIsNotRemovable = true;
}
else {
cacheEntryIsNotRemovable = !isRemovable;
WebConfigurationHost.GetSiteIDAndVPathFromConfigPath(configPath, out siteID, out virtualPath);
physicalPath = GetPhysicalPath(virtualPath);
// Add a dependency on the path itself, if it is a file,
// to handle the case where a file is deleted and replaced
// with a directory of the same name.
if (!String.IsNullOrEmpty(physicalPath)) {
FileUtil.PhysicalPathStatus(physicalPath, false, false, out exists, out isDirectory);
if (exists && !isDirectory) {
fileDependencies = new string[1] {physicalPath};
}
}
}
try {
dependency = new CacheDependency(0, fileDependencies, cacheItemDependencies);
}
catch {
// CacheDependency ctor could fail because of bogus file path
// and it is ok not to watch those
}
}
// Try to add the CachedPathData to the cache.
CachedPathData dataAdd = null;
bool isDataCreator = false;
bool initCompleted = false;
CacheItemPriority priority = cacheEntryIsNotRemovable ? CacheItemPriority.NotRemovable : CacheItemPriority.Normal;
TimeSpan slidingExpiration = cacheEntryIsNotRemovable ? Cache.NoSlidingExpiration : UrlMetadataSlidingExpiration;
try {
using (dependency) {
dataAdd = new CachedPathData(configPath, virtualPath, physicalPath, exists);
try {
}
finally {
data = (CachedPathData) cacheInternal.UtcAdd(key, dataAdd, dependency,
Cache.NoAbsoluteExpiration, slidingExpiration,
priority, s_callback);
if (data == null) {
isDataCreator = true;
}
}
}
// If another thread added it first, return the data
if (!isDataCreator) {
data.WaitForInit();
return data;
}
// This thread is the creator of the CachedPathData, initialize it
lock (dataAdd) {
try {
dataAdd.Init(parentData);
initCompleted = true;
}
finally {
// free waiters
dataAdd._flags[FInited] = true;
// Wake up waiters.
Monitor.PulseAll(dataAdd);
if (dataAdd._flags[FCloseNeeded]) {
// If we have received a call back to close, then lets
// make sure that our config object is cleaned up
dataAdd.Close();
}
}
}
}
finally {
// All the work in this finally block is for the case where we're the
// creator of the CachedPathData.
if (isDataCreator) {
//
if (!dataAdd._flags[FInited]) {
lock (dataAdd) {
// free waiters
dataAdd._flags[FInited] = true;
// Wake up waiters.
Monitor.PulseAll(dataAdd);
if (dataAdd._flags[FCloseNeeded]) {
// If we have received a call back to close, then lets
// make sure that our config object is cleaned up
dataAdd.Close();
}
}
}
//
// Even though there is a try/catch handler surrounding the call to Init,
// a ThreadAbortException can still cause the handler to be bypassed.
//
// If there is an error, either a thread abort or an error in the config
// file itself, we do want to leave the item cached for a short period
// so that we do not revisit the error and potentially reparse the config file
// on every request.
//
// The reason we simply do not leave the item in the cache forever is that the
// problem that caused the configuration exception may be fixed without touching
// the config file in a way that causes a file change notification (for example, an
// acl change in a parent directory, or a change of path mapping in the metabase).
//
// NOTE: It is important to reinsert the item into the cache AFTER dropping
// the lock on dataAdd, in order to prevent the possibility of deadlock.
//
Debug.Assert(dataAdd._flags[FInited], "_flags[FInited]");
if (!initCompleted || (dataAdd.ConfigRecord != null && dataAdd.ConfigRecord.HasInitErrors)) {
//
// Create a new dependency object as the old one cannot be reused.
// Do not include a file dependency if initialization could not be completed,
// as invoking the file system could lead to further errors during a thread abort.
//
if (dependency != null) {
if (!initCompleted) {
dependency = new CacheDependency(0, null, cacheItemDependencies);
}
else {
dependency = new CacheDependency(0, fileDependencies, cacheItemDependencies);
}
}
using (dependency) {
cacheInternal.UtcInsert(key, dataAdd, dependency,
DateTime.UtcNow.AddSeconds(5), Cache.NoSlidingExpiration,
CacheItemPriority.Normal, s_callback);
}
}
}
}
return dataAdd;
}
// Ensure that the physical path does not look suspicious (MSRC 5556).
static private string GetPhysicalPath(VirtualPath virtualPath) {
string physicalPath = null;
try {
physicalPath = virtualPath.MapPathInternal(true);
}
catch (HttpException e) {
//
// Treat exceptions that are thrown because the path is suspicious
// as "404 Not Found" exceptions. Implementations of MapPath
// will throw HttpException with no error code if the path is
// suspicious.
//
if (e.GetHttpCode() == 500) {
throw new HttpException(404, String.Empty);
}
else {
throw;
}
}
//
// Throw "404 Not Found" if the path is suspicious and
// the implementation of MapPath has not already done so.
//
FileUtil.CheckSuspiciousPhysicalPath(physicalPath);
return physicalPath;
}
// Remove CachedPathData when the first request for the path results in a
// 400 range error. We need to remove all data up the path to account for
// virtual files.
// An example of a 400 range error is "path not found".
static internal void RemoveBadPathData(CachedPathData pathData) {
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
string configPath = pathData._configPath;
string key = CreateKey(configPath);
while (pathData != null && !pathData.CompletedFirstRequest && !pathData.Exists) {
cacheInternal.Remove(key);
configPath = ConfigPathUtility.GetParent(configPath);
if (configPath == null)
break;
key = CreateKey(configPath);
pathData = (CachedPathData) cacheInternal.Get(key);
}
}
// Mark CachedPathData as completed when the first request for the path results in a
// status outside the 400 range. We need to mark all data up the path to account for
// virtual files.
static internal void MarkCompleted(CachedPathData pathData) {
CacheInternal cacheInternal = HttpRuntime.CacheInternal;
string configPath = pathData._configPath;
do {
pathData.CompletedFirstRequest = true;
configPath = ConfigPathUtility.GetParent(configPath);
if (configPath == null)
break;
string key = CreateKey(configPath);
pathData = (CachedPathData) cacheInternal.Get(key);
} while (pathData != null && !pathData.CompletedFirstRequest);
}
// Close
//
// Close the object. This does not mean it can not be used anymore,
// it just means that the cleanup as been done, so we don't have
// to worry about closing it anymore
//
void Close() {
// Only close if we are propertly initialized
if (_flags[FInited]) {
// Only close if we haven't already closed
if (_flags.ChangeValue(FClosed, true)) {
// Remove the config record if we own it
// N.B. ConfigRecord.Remove is safe to call more than once.
if (_flags[FOwnsConfigRecord]) {
ConfigRecord.Remove();
}
}
}
}
// OnCacheItemRemoved
//
// Notification the items has been removed from the cache. Flag
// the item to be cleaned up, and then try cleanup
//
static void OnCacheItemRemoved(string key, object value, CacheItemRemovedReason reason) {
CachedPathData data = (CachedPathData) value;
data._flags[FCloseNeeded] = true;
data.Close();
}
static string CreateKey(string configPath) {
Debug.Assert(configPath == configPath.ToLower(CultureInfo.InvariantCulture), "configPath == configPath.ToLower(CultureInfo.InvariantCulture)");
return CacheInternal.PrefixPathData + configPath;
}
// Initialize the data
void Init(CachedPathData parentData) {
// Note that _runtimeConfig will be set to the singleton instance of ErrorRuntimeConfig
// if a ThreadAbortException is thrown during this method.
Debug.Assert(_runtimeConfig == RuntimeConfig.GetErrorRuntimeConfig(), "_runtimeConfig == RuntimeConfig.GetErrorRuntimeConfig()");
if (!HttpConfigurationSystem.UseHttpConfigurationSystem) {
//
// configRecord may legitimately be null if we are not using the HttpConfigurationSystem.
//
_runtimeConfig = null;
}
else {
IInternalConfigRecord configRecord = HttpConfigurationSystem.GetUniqueConfigRecord(_configPath);
Debug.Assert(configRecord != null, "configRecord != null");
if (configRecord.ConfigPath.Length == _configPath.Length) {
//
// The config is unique to this path, so this make this record the owner of the config.
//
_flags[FOwnsConfigRecord] = true;
_runtimeConfig = new RuntimeConfig(configRecord);
}
else {
//
// The config record is the same as an ancestor's, so use the parent's RuntimeConfig.
//
Debug.Assert(parentData != null, "parentData != null");
_runtimeConfig = parentData._runtimeConfig;
}
}
}
void WaitForInit() {
// Wait for the data to be initialized.
if (!_flags[FInited]) {
lock (this) {
if (!_flags[FInited]) {
Monitor.Wait(this);
}
}
}
}
// Ensure that Request.PhysicalPath is valid (canonical, not too long, and contains valid characters).
// The work is done by CheckSuspiciousPhysicalPath, but as a perf optimization, we can compare
// Request.PhysicalPath with the cached path result. The cached path result is validated before
// it is cached. As long as the cached path result is identical to Request.PhysicalPath, we don't
// have to call CheckSuspiciousPhysicalPath again.
internal void ValidatePath(String physicalPath) {
if (String.IsNullOrEmpty(_physicalPath) && String.IsNullOrEmpty(physicalPath)) {
return;
}
if (!String.IsNullOrEmpty(_physicalPath) && !String.IsNullOrEmpty(physicalPath)) {
if (_physicalPath.Length == physicalPath.Length) {
// if identical, we don't have to call CheckSuspiciousPhysicalPath
if (0 == String.Compare(_physicalPath, 0, physicalPath, 0, physicalPath.Length, StringComparison.OrdinalIgnoreCase)) {
return;
}
}
else if (_physicalPath.Length - physicalPath.Length == 1) {
// if they differ by a trailing slash, we shouldn't call CheckSuspiciousPhysicalPath again
if (_physicalPath[_physicalPath.Length-1] == System.IO.Path.DirectorySeparatorChar
&& (0 == String.Compare(_physicalPath, 0, physicalPath, 0, physicalPath.Length, StringComparison.OrdinalIgnoreCase))) {
return;
}
}
else if (physicalPath.Length - _physicalPath.Length == 1) {
// if they differ by a trailing slash, we shouldn't call CheckSuspiciousPhysicalPath again
if (physicalPath[physicalPath.Length-1] == System.IO.Path.DirectorySeparatorChar
&& (0 == String.Compare(_physicalPath, 0, physicalPath, 0, _physicalPath.Length, StringComparison.OrdinalIgnoreCase))) {
return;
}
}
}
// If we're here, the paths were different, which normally should not happen.
Debug.Assert(false, "ValidatePath optimization failed: Request.PhysicalPath="
+ physicalPath + "; _physicalPath=" + _physicalPath);
FileUtil.CheckSuspiciousPhysicalPath(physicalPath);
}
internal bool CompletedFirstRequest {
get {return _flags[FCompletedFirstRequest];}
set {
_flags[FCompletedFirstRequest] = value;
}
}
internal VirtualPath Path {
get {return _virtualPath;}
}
internal string PhysicalPath {
get { return _physicalPath; }
}
internal bool AnonymousAccessChecked {
get { return _flags[FAnonymousAccessChecked]; }
set { _flags[FAnonymousAccessChecked] = value; }
}
internal bool AnonymousAccessAllowed {
get { return _flags[FAnonymousAccessAllowed]; }
set { _flags[FAnonymousAccessAllowed] = value; }
}
internal bool Exists {
get {return _flags[FExists];}
}
internal HandlerMappingMemo CachedHandler {
get {return _handlerMemo;}
set {_handlerMemo = value;}
}
internal IInternalConfigRecord ConfigRecord {
get {
// _runtimeConfig may be null if we are not using the HttpConfigurationSystem.
return (_runtimeConfig != null) ? _runtimeConfig.ConfigRecord : null;
}
}
internal RuntimeConfig RuntimeConfig {
get {
return _runtimeConfig;
}
}
// Any time we cache metadata for the URL, we should use this
// sliding expiration, unless DoNotCacheUrlMetadata is true.
// This is currently used by CachedPathData, MapPathBasedVirtualPathProvider,
// and FileAuthorizationModule
internal static TimeSpan UrlMetadataSlidingExpiration {
get {
return s_urlMetadataSlidingExpiration;
}
}
// if true, do not cache at all.
internal static bool DoNotCacheUrlMetadata {
get { return s_doNotCacheUrlMetadata; }
}
}
}
// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
Link Menu
This book is available now!
Buy at Amazon US or
Buy at Amazon UK
- ArrayTypeMismatchException.cs
- Process.cs
- PersonalizationStateInfo.cs
- DropShadowBitmapEffect.cs
- DecoderFallbackWithFailureFlag.cs
- Border.cs
- WorkflowFileItem.cs
- ValueExpressions.cs
- TypeSystemProvider.cs
- FixUp.cs
- DataGridViewDataConnection.cs
- BitmapFrameEncode.cs
- BypassElement.cs
- ZipIOCentralDirectoryDigitalSignature.cs
- NativeMethods.cs
- shaperfactoryquerycacheentry.cs
- IItemContainerGenerator.cs
- PanelDesigner.cs
- WebConvert.cs
- SecurityVersion.cs
- Margins.cs
- Grant.cs
- ObjectDataSourceMethodEventArgs.cs
- BigInt.cs
- Context.cs
- TextTreeDeleteContentUndoUnit.cs
- PointAnimationUsingKeyFrames.cs
- ToolStripHighContrastRenderer.cs
- CopyOfAction.cs
- CryptoApi.cs
- coordinatorscratchpad.cs
- XmlDesignerDataSourceView.cs
- SecurityDescriptor.cs
- COM2AboutBoxPropertyDescriptor.cs
- CheckBoxBaseAdapter.cs
- HexParser.cs
- GlyphRun.cs
- DrawingVisual.cs
- AppDomainCompilerProxy.cs
- MasterPage.cs
- DataColumnCollection.cs
- UpdateTracker.cs
- ResourceAssociationSetEnd.cs
- HashCodeCombiner.cs
- IisTraceListener.cs
- MemoryMappedFile.cs
- Action.cs
- RuleRefElement.cs
- WebPartZone.cs
- DotExpr.cs
- CustomExpression.cs
- TypeConverter.cs
- TimeoutHelper.cs
- SystemDiagnosticsSection.cs
- TranslateTransform3D.cs
- AdRotatorDesigner.cs
- ReaderWriterLock.cs
- BridgeDataRecord.cs
- PngBitmapEncoder.cs
- DataGridBoolColumn.cs
- ThicknessAnimationBase.cs
- UnmanagedBitmapWrapper.cs
- XmlSchemaCollection.cs
- hebrewshape.cs
- AddressAccessDeniedException.cs
- ListViewCancelEventArgs.cs
- BaseDataBoundControlDesigner.cs
- PopOutPanel.cs
- WindowsUserNameSecurityTokenAuthenticator.cs
- SqlServices.cs
- FacetDescription.cs
- PeerServiceMessageContracts.cs
- SafeCertificateContext.cs
- ExtendedPropertyDescriptor.cs
- ForEachAction.cs
- WinFormsComponentEditor.cs
- ScrollBarAutomationPeer.cs
- PreProcessInputEventArgs.cs
- coordinatorfactory.cs
- DataGridTablesFactory.cs
- sqlser.cs
- ItemsPanelTemplate.cs
- VisualStyleTypesAndProperties.cs
- SingleQueryOperator.cs
- MDIControlStrip.cs
- ReturnEventArgs.cs
- ReadOnlyCollectionBase.cs
- httpapplicationstate.cs
- ListViewItemCollectionEditor.cs
- PeerSecurityHelpers.cs
- ExtractedStateEntry.cs
- ReflectPropertyDescriptor.cs
- WebPartCloseVerb.cs
- DataSourceControlBuilder.cs
- Constraint.cs
- ComponentEditorForm.cs
- WindowShowOrOpenTracker.cs
- DesignerTransaction.cs
- HttpResponse.cs
- TemplateNameScope.cs