mirror of
https://github.com/BepInEx/mono.git
synced 2026-11-19 01:31:17 -10:00
Adding reference source for System.Data System.Data.DataSetExtensions System.Data.Entity System.Data.Entity.Design System.Data.Linq System.Data.SqlXml System.ServiceModel System.ServiceModel.Activation System.ServiceModel.Activities System.ServiceModel.Channels System.ServiceModel.Discovery System.ServiceModel.Internals System.ServiceModel.Routing System.ServiceModel.WasHosting System.ServiceModel.Web System.Web System.Web.ApplicationServices System.Web.DynamicData System.Web.Entity System.Web.Entity.Design System.Web.Extensions System.Web.Mobile System.Web.Routing System.Web.Services System.Xml System.Xml.Linq
367 lines
16 KiB
C#
367 lines
16 KiB
C#
//-----------------------------------------------------------------------------
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
//-----------------------------------------------------------------------------
|
|
|
|
using System.Collections.Generic;
|
|
using System.Diagnostics;
|
|
using System.Runtime;
|
|
using System.Runtime.Serialization;
|
|
using System.Security;
|
|
using System.ServiceModel;
|
|
using System.ServiceModel.Channels;
|
|
using System.ServiceModel.Diagnostics;
|
|
using System.ServiceModel.Dispatcher;
|
|
using System.Web;
|
|
using System.Web.Caching;
|
|
using System.Web.Configuration;
|
|
using System.Web.UI;
|
|
using System.ServiceModel.Activation;
|
|
|
|
namespace System.ServiceModel.Web
|
|
{
|
|
class CachingParameterInspector : IParameterInspector
|
|
{
|
|
const char seperatorChar = ';';
|
|
const char escapeChar = '\\';
|
|
const char tableDbSeperatorChar = ':';
|
|
const string invalidSqlDependencyString = "Invalid Sql dependency string.";
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "A config object, which should not be leaked.")]
|
|
[SecurityCritical]
|
|
OutputCacheProfile cacheProfile;
|
|
|
|
SqlDependencyInfo[] cacheDependencyInfoArray;
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Handles config objects, which should not be leaked.",
|
|
Safe = "The config object never leaves the CachingParameterInspector.")]
|
|
[SecuritySafeCritical]
|
|
public CachingParameterInspector(string cacheProfileName)
|
|
{
|
|
if (string.IsNullOrEmpty(cacheProfileName))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.CacheProfileNameNullOrEmpty));
|
|
}
|
|
|
|
OutputCacheSettingsSection cacheSettings = AspNetEnvironment.Current.UnsafeGetConfigurationSection("system.web/caching/outputCacheSettings") as OutputCacheSettingsSection;
|
|
if (cacheSettings == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.GetString(SR2.CacheProfileNotConfigured, cacheProfileName)));
|
|
}
|
|
|
|
this.cacheProfile = cacheSettings.OutputCacheProfiles[cacheProfileName];
|
|
if (this.cacheProfile == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.GetString(SR2.CacheProfileNotConfigured, cacheProfileName)));
|
|
}
|
|
|
|
// Validate the cacheProfile
|
|
if (this.cacheProfile.Location != OutputCacheLocation.None)
|
|
{
|
|
// Duration must be set; Duration default value is -1
|
|
if (this.cacheProfile.Duration == -1)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.GetString(SR2.CacheProfileValueMissing, this.cacheProfile.Name, "Duration")));
|
|
}
|
|
if (this.cacheProfile.VaryByParam == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.GetString(SR2.CacheProfileValueMissing, this.cacheProfile.Name, "VaryByParam")));
|
|
}
|
|
}
|
|
|
|
if (string.Equals(this.cacheProfile.SqlDependency, "CommandNotification", StringComparison.OrdinalIgnoreCase))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.CommandNotificationSqlDependencyNotSupported));
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(this.cacheProfile.SqlDependency))
|
|
{
|
|
ParseSqlDependencyString(cacheProfile.SqlDependency);
|
|
}
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Handles config objects, which should not be leaked.",
|
|
Safe = "The config object never leaves the CachingParameterInspector.")]
|
|
[SecuritySafeCritical]
|
|
public void AfterCall(string operationName, object[] outputs, object returnValue, object correlationState)
|
|
{
|
|
if (this.cacheProfile != null &&
|
|
this.cacheProfile.Enabled &&
|
|
OperationContext.Current.IncomingMessage.Version == MessageVersion.None)
|
|
{
|
|
if (DiagnosticUtility.ShouldTraceWarning && !IsAnonymous())
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.AddingAuthenticatedResponseToOutputCache, SR2.GetString(SR2.TraceCodeAddingAuthenticatedResponseToOutputCache, operationName));
|
|
}
|
|
else if (DiagnosticUtility.ShouldTraceInformation)
|
|
{
|
|
TraceUtility.TraceEvent(TraceEventType.Information, TraceCode.AddingResponseToOutputCache, SR2.GetString(SR2.TraceCodeAddingResponseToOutputCache, operationName));
|
|
}
|
|
|
|
SetCacheFromCacheProfile();
|
|
}
|
|
}
|
|
|
|
public object BeforeCall(string operationName, object[] inputs)
|
|
{
|
|
return null;
|
|
}
|
|
|
|
bool IsAnonymous()
|
|
{
|
|
if (HttpContext.Current.User.Identity.IsAuthenticated)
|
|
{
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if (OperationContext.Current.ServiceSecurityContext == null)
|
|
{
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
return OperationContext.Current.ServiceSecurityContext.IsAnonymous;
|
|
}
|
|
}
|
|
}
|
|
|
|
static SqlDependencyInfo[] ParseSqlDependencyString(string sqlDependencyString)
|
|
{
|
|
// The code for this method was taken from private code in
|
|
// System.Web.SqlCacheDependency.ParseSql7OutputCacheDependency.
|
|
// Alter if only absolutely necessary since we want to reproduce the same ASP.NET caching behavior.
|
|
|
|
List<SqlDependencyInfo> dependencyList = new List<SqlDependencyInfo>();
|
|
bool escapeSequenceFlag = false;
|
|
int startIndexForDatabaseName = 0;
|
|
int startIndexForTableName = -1;
|
|
string databaseName = null;
|
|
|
|
try
|
|
{
|
|
for (int currentIndex = 0; currentIndex < (sqlDependencyString.Length + 1); currentIndex++)
|
|
{
|
|
if (escapeSequenceFlag)
|
|
{
|
|
escapeSequenceFlag = false;
|
|
}
|
|
else if ((currentIndex != sqlDependencyString.Length) &&
|
|
(sqlDependencyString[currentIndex] == escapeChar))
|
|
{
|
|
escapeSequenceFlag = true;
|
|
}
|
|
else
|
|
{
|
|
int subStringLength;
|
|
if ((currentIndex == sqlDependencyString.Length) ||
|
|
(sqlDependencyString[currentIndex] == seperatorChar))
|
|
{
|
|
if (databaseName == null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(invalidSqlDependencyString);
|
|
}
|
|
subStringLength = currentIndex - startIndexForTableName;
|
|
if (subStringLength == 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(invalidSqlDependencyString);
|
|
}
|
|
string tableName = sqlDependencyString.Substring(startIndexForTableName, subStringLength);
|
|
SqlDependencyInfo info = new SqlDependencyInfo();
|
|
info.Database = VerifyAndRemoveEscapeCharacters(databaseName);
|
|
info.Table = VerifyAndRemoveEscapeCharacters(tableName);
|
|
dependencyList.Add(info);
|
|
startIndexForDatabaseName = currentIndex + 1;
|
|
databaseName = null;
|
|
}
|
|
if (currentIndex == sqlDependencyString.Length)
|
|
{
|
|
break;
|
|
}
|
|
if (sqlDependencyString[currentIndex] == tableDbSeperatorChar)
|
|
{
|
|
if (databaseName != null)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(invalidSqlDependencyString);
|
|
}
|
|
subStringLength = currentIndex - startIndexForDatabaseName;
|
|
if (subStringLength == 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(invalidSqlDependencyString);
|
|
}
|
|
databaseName = sqlDependencyString.Substring(startIndexForDatabaseName, subStringLength);
|
|
startIndexForTableName = currentIndex + 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
catch (ArgumentException)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.GetString(SR2.CacheProfileSqlDependencyIsInvalid, sqlDependencyString)));
|
|
}
|
|
if (dependencyList.Count == 0)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new InvalidOperationException(SR2.GetString(SR2.CacheProfileSqlDependencyIsInvalid, sqlDependencyString)));
|
|
}
|
|
return dependencyList.ToArray();
|
|
}
|
|
|
|
static string VerifyAndRemoveEscapeCharacters(string str)
|
|
{
|
|
// The code for this method was taken from private code in
|
|
// System.Web.SqlCacheDependency.VerifyAndRemoveEscapeCharacters.
|
|
// Alter if only absolutely necessary since we want to reproduce the same ASP.NET caching behavior.
|
|
|
|
bool escapeSequenceFlag = false;
|
|
for (int currentIndex = 0; currentIndex < str.Length; currentIndex++)
|
|
{
|
|
if (escapeSequenceFlag)
|
|
{
|
|
if (((str[currentIndex] != escapeChar) &&
|
|
(str[currentIndex] != tableDbSeperatorChar)) &&
|
|
(str[currentIndex] != seperatorChar))
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(str);
|
|
}
|
|
escapeSequenceFlag = false;
|
|
}
|
|
else if (str[currentIndex] == escapeChar)
|
|
{
|
|
if ((currentIndex + 1) == str.Length)
|
|
{
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperArgument(str);
|
|
}
|
|
escapeSequenceFlag = true;
|
|
str = str.Remove(currentIndex, 1);
|
|
currentIndex--;
|
|
}
|
|
}
|
|
return str;
|
|
}
|
|
|
|
CacheDependency CreateSingleCacheDependency(string sqlDependency)
|
|
{
|
|
if (this.cacheDependencyInfoArray == null)
|
|
{
|
|
this.cacheDependencyInfoArray = CachingParameterInspector.ParseSqlDependencyString(sqlDependency);
|
|
}
|
|
|
|
// cacheDependencyInfoArray will never have length = 0
|
|
|
|
if (this.cacheDependencyInfoArray.Length == 1)
|
|
{
|
|
return new SqlCacheDependency(this.cacheDependencyInfoArray[0].Database, this.cacheDependencyInfoArray[0].Table);
|
|
}
|
|
|
|
AggregateCacheDependency cacheDependency = new AggregateCacheDependency();
|
|
foreach (SqlDependencyInfo dependencyInfo in this.cacheDependencyInfoArray)
|
|
{
|
|
cacheDependency.Add(new CacheDependency[] { new SqlCacheDependency(dependencyInfo.Database, dependencyInfo.Table) });
|
|
}
|
|
return cacheDependency;
|
|
}
|
|
|
|
[Fx.Tag.SecurityNote(Critical = "Uses config object to set properties of the HttpCachePolicy.",
|
|
Safe = "The config object itself doesn't leak.")]
|
|
[SecuritySafeCritical]
|
|
void SetCacheFromCacheProfile()
|
|
{
|
|
HttpCachePolicy cache = HttpContext.Current.Response.Cache;
|
|
|
|
if (this.cacheProfile.NoStore)
|
|
{
|
|
cache.SetNoStore();
|
|
}
|
|
|
|
// Location is not required to be set in the config. The default is Any,
|
|
// but if it is not set in the config the value will be -1. So must correct for this.
|
|
if ((int)(this.cacheProfile.Location) == -1)
|
|
{
|
|
cache.SetCacheability(HttpCacheability.Public);
|
|
}
|
|
else
|
|
{
|
|
switch (this.cacheProfile.Location)
|
|
{
|
|
case OutputCacheLocation.Any:
|
|
cache.SetCacheability(HttpCacheability.Public);
|
|
break;
|
|
case OutputCacheLocation.Client:
|
|
cache.SetCacheability(HttpCacheability.Private);
|
|
break;
|
|
case OutputCacheLocation.Downstream:
|
|
cache.SetCacheability(HttpCacheability.Public);
|
|
cache.SetNoServerCaching();
|
|
break;
|
|
case OutputCacheLocation.None:
|
|
cache.SetCacheability(HttpCacheability.NoCache);
|
|
break;
|
|
case OutputCacheLocation.Server:
|
|
cache.SetCacheability(HttpCacheability.ServerAndNoCache);
|
|
break;
|
|
case OutputCacheLocation.ServerAndClient:
|
|
cache.SetCacheability(HttpCacheability.ServerAndPrivate);
|
|
break;
|
|
default:
|
|
throw DiagnosticUtility.ExceptionUtility.ThrowHelperError(new NotSupportedException(SR2.GetString(SR2.CacheProfileLocationNotSupported, this.cacheProfile.Location)));
|
|
}
|
|
}
|
|
|
|
if (this.cacheProfile.Location != OutputCacheLocation.None)
|
|
{
|
|
cache.SetExpires(HttpContext.Current.Timestamp.AddSeconds((double)this.cacheProfile.Duration));
|
|
cache.SetMaxAge(new TimeSpan(0, 0, this.cacheProfile.Duration));
|
|
cache.SetValidUntilExpires(true);
|
|
cache.SetLastModified(HttpContext.Current.Timestamp);
|
|
|
|
if (this.cacheProfile.Location != OutputCacheLocation.Client)
|
|
{
|
|
if (!string.IsNullOrEmpty(this.cacheProfile.VaryByContentEncoding))
|
|
{
|
|
foreach (string contentEncoding in this.cacheProfile.VaryByContentEncoding.Split(seperatorChar))
|
|
{
|
|
cache.VaryByContentEncodings[contentEncoding.Trim()] = true;
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(this.cacheProfile.VaryByHeader))
|
|
{
|
|
foreach (string header in this.cacheProfile.VaryByHeader.Split(seperatorChar))
|
|
{
|
|
cache.VaryByHeaders[header.Trim()] = true;
|
|
}
|
|
}
|
|
|
|
if (this.cacheProfile.Location != OutputCacheLocation.Downstream)
|
|
{
|
|
if (!string.IsNullOrEmpty(this.cacheProfile.VaryByCustom))
|
|
{
|
|
cache.SetVaryByCustom(this.cacheProfile.VaryByCustom);
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(this.cacheProfile.VaryByParam))
|
|
{
|
|
foreach (string parameter in cacheProfile.VaryByParam.Split(seperatorChar))
|
|
{
|
|
cache.VaryByParams[parameter.Trim()] = true;
|
|
}
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(this.cacheProfile.SqlDependency))
|
|
{
|
|
CacheDependency cacheDependency = this.CreateSingleCacheDependency(cacheProfile.SqlDependency);
|
|
HttpContext.Current.Response.AddCacheDependency(new CacheDependency[] { cacheDependency });
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private struct SqlDependencyInfo
|
|
{
|
|
public string Database;
|
|
public string Table;
|
|
}
|
|
|
|
}
|
|
}
|