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
729 lines
38 KiB
C#
729 lines
38 KiB
C#
//------------------------------------------------------------------------------
|
|
// <copyright file="AssemblyResourceLoader.cs" company="Microsoft">
|
|
// Copyright (c) Microsoft Corporation. All rights reserved.
|
|
// </copyright>
|
|
//------------------------------------------------------------------------------
|
|
namespace System.Web.Handlers {
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Specialized;
|
|
using System.Globalization;
|
|
using System.IO;
|
|
using System.Reflection;
|
|
using System.Security.Permissions;
|
|
using System.Text;
|
|
using System.Text.RegularExpressions;
|
|
using System.Web;
|
|
using System.Web.Compilation;
|
|
using System.Web.Configuration;
|
|
using System.Web.Hosting;
|
|
using System.Web.Management;
|
|
using System.Web.RegularExpressions;
|
|
using System.Web.Security.Cryptography;
|
|
using System.Web.UI;
|
|
using System.Web.Util;
|
|
|
|
|
|
/// <devdoc>
|
|
/// Provides a way to load client-side resources from assemblies
|
|
/// </devdoc>
|
|
public sealed class AssemblyResourceLoader : IHttpHandler {
|
|
private const string _webResourceUrl = "WebResource.axd";
|
|
|
|
private readonly static Regex webResourceRegex = new WebResourceRegex();
|
|
|
|
private static IDictionary _urlCache = Hashtable.Synchronized(new Hashtable());
|
|
private static IDictionary _assemblyInfoCache = Hashtable.Synchronized(new Hashtable());
|
|
private static IDictionary _webResourceCache = Hashtable.Synchronized(new Hashtable());
|
|
private static IDictionary _typeAssemblyCache = Hashtable.Synchronized(new Hashtable());
|
|
|
|
// This group of fields is used for backwards compatibility. In v1.x you could
|
|
// technically customize the files in the /aspnet_client/ folder whereas in v2.x
|
|
// we serve those files using WebResource.axd. These fields are used to check
|
|
// if there is a customized version of the file and use that instead of the resource.
|
|
private static bool _webFormsScriptChecked;
|
|
private static VirtualPath _webFormsScriptLocation;
|
|
private static bool _webUIValidationScriptChecked;
|
|
private static VirtualPath _webUIValidationScriptLocation;
|
|
private static bool _smartNavScriptChecked;
|
|
private static VirtualPath _smartNavScriptLocation;
|
|
private static bool _smartNavPageChecked;
|
|
private static VirtualPath _smartNavPageLocation;
|
|
|
|
private static bool _handlerExistenceChecked;
|
|
private static bool _handlerExists;
|
|
// set by unit tests to avoid dependency on httpruntime.
|
|
internal static string _applicationRootPath;
|
|
|
|
private static bool DebugMode {
|
|
get {
|
|
return HttpContext.Current.IsDebuggingEnabled;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Create a cache key for the UrlCache.
|
|
///
|
|
/// requirement: If assembly1 and assembly2 represent the same assembly,
|
|
/// then they must be the same object; otherwise this method will fail to generate
|
|
/// a unique cache key.
|
|
/// </devdoc>
|
|
private static int CreateWebResourceUrlCacheKey(Assembly assembly, string resourceName,
|
|
bool htmlEncoded, bool forSubstitution, bool enableCdn, bool debuggingEnabled, bool secureConnection) {
|
|
int hashCode = HashCodeCombiner.CombineHashCodes(
|
|
assembly.GetHashCode(),
|
|
resourceName.GetHashCode(),
|
|
htmlEncoded.GetHashCode(),
|
|
forSubstitution.GetHashCode(),
|
|
enableCdn.GetHashCode());
|
|
return HashCodeCombiner.CombineHashCodes(hashCode,
|
|
debuggingEnabled.GetHashCode(),
|
|
secureConnection.GetHashCode());
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Validates that the WebResource.axd handler is registered in config and actually
|
|
/// points to the correct handler type.
|
|
/// </devdoc>
|
|
private static void EnsureHandlerExistenceChecked() {
|
|
// First we have to check that the handler is registered:
|
|
// <add path="WebResource.axd" verb="GET" type="System.Web.Handlers.AssemblyResourceLoader" validate="True" />
|
|
if (!_handlerExistenceChecked) {
|
|
HttpContext context = HttpContext.Current;
|
|
IIS7WorkerRequest iis7WorkerRequest = (context != null) ? context.WorkerRequest as IIS7WorkerRequest : null;
|
|
string webResourcePath = UrlPath.Combine(HttpRuntime.AppDomainAppVirtualPathString, _webResourceUrl);
|
|
if (iis7WorkerRequest != null) {
|
|
// check the IIS <handlers> section by mapping the handler
|
|
string handlerTypeString = iis7WorkerRequest.MapHandlerAndGetHandlerTypeString(method: "GET",
|
|
path: UrlPath.Combine(HttpRuntime.AppDomainAppVirtualPathString, _webResourceUrl),
|
|
convertNativeStaticFileModule: false, ignoreWildcardMappings: true);
|
|
if (!String.IsNullOrEmpty(handlerTypeString)) {
|
|
_handlerExists = (typeof(AssemblyResourceLoader) == BuildManager.GetType(handlerTypeString, true /*throwOnFail*/, false /*ignoreCase*/));
|
|
}
|
|
}
|
|
else {
|
|
// check the <httpHandlers> section
|
|
HttpHandlerAction httpHandler = RuntimeConfig.GetConfig(VirtualPath.Create(webResourcePath)).HttpHandlers.FindMapping("GET", VirtualPath.Create(_webResourceUrl));
|
|
_handlerExists = (httpHandler != null) && (httpHandler.TypeInternal == typeof(AssemblyResourceLoader));
|
|
}
|
|
_handlerExistenceChecked = true;
|
|
}
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Performs the actual putting together of the resource reference URL.
|
|
/// </devdoc>
|
|
private static string FormatWebResourceUrl(string assemblyName, string resourceName, long assemblyDate, bool htmlEncoded) {
|
|
string encryptedData = Page.EncryptString(assemblyName + "|" + resourceName, Purpose.AssemblyResourceLoader_WebResourceUrl);
|
|
if (htmlEncoded) {
|
|
return String.Format(CultureInfo.InvariantCulture, _webResourceUrl + "?d={0}&t={1}",
|
|
encryptedData,
|
|
assemblyDate);
|
|
}
|
|
else {
|
|
return String.Format(CultureInfo.InvariantCulture, _webResourceUrl + "?d={0}&t={1}",
|
|
encryptedData,
|
|
assemblyDate);
|
|
}
|
|
}
|
|
|
|
internal static Assembly GetAssemblyFromType(Type type) {
|
|
Assembly assembly = (Assembly)_typeAssemblyCache[type];
|
|
if (assembly == null) {
|
|
assembly = type.Assembly;
|
|
_typeAssemblyCache[type] = assembly;
|
|
}
|
|
return assembly;
|
|
}
|
|
|
|
private static Pair GetAssemblyInfo(Assembly assembly) {
|
|
Pair assemblyInfo = _assemblyInfoCache[assembly] as Pair;
|
|
if (assemblyInfo == null) {
|
|
assemblyInfo = GetAssemblyInfoWithAssertInternal(assembly);
|
|
_assemblyInfoCache[assembly] = assemblyInfo;
|
|
}
|
|
Debug.Assert(assemblyInfo != null, "Assembly info should not be null");
|
|
return assemblyInfo;
|
|
}
|
|
|
|
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
|
|
private static Pair GetAssemblyInfoWithAssertInternal(Assembly assembly) {
|
|
AssemblyName assemblyName = assembly.GetName();
|
|
long assemblyDate = File.GetLastWriteTime(new Uri(assemblyName.CodeBase).LocalPath).Ticks;
|
|
Pair assemblyInfo = new Pair(assemblyName, assemblyDate);
|
|
return assemblyInfo;
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets the virtual path of a physical resource file. Null is
|
|
/// returned if the resource does not exist.
|
|
/// We assert full FileIOPermission so that we can map paths.
|
|
/// </devdoc>
|
|
[FileIOPermission(SecurityAction.Assert, Unrestricted = true)]
|
|
private static VirtualPath GetDiskResourcePath(string resourceName) {
|
|
VirtualPath clientScriptsLocation = Util.GetScriptLocation();
|
|
VirtualPath resourceVirtualPath = clientScriptsLocation.SimpleCombine(resourceName);
|
|
string resourcePhysicalPath = resourceVirtualPath.MapPath();
|
|
if (File.Exists(resourcePhysicalPath)) {
|
|
return resourceVirtualPath;
|
|
}
|
|
else {
|
|
return null;
|
|
}
|
|
}
|
|
|
|
internal static string GetWebResourceUrl(Type type, string resourceName) {
|
|
return GetWebResourceUrl(type, resourceName, false, null);
|
|
}
|
|
|
|
internal static string GetWebResourceUrl(Type type, string resourceName, bool htmlEncoded) {
|
|
return GetWebResourceUrl(type, resourceName, htmlEncoded, null);
|
|
}
|
|
|
|
internal static string GetWebResourceUrl(Type type, string resourceName, bool htmlEncoded, IScriptManager scriptManager) {
|
|
bool enableCdn = (scriptManager != null && scriptManager.EnableCdn);
|
|
return GetWebResourceUrl(type, resourceName, htmlEncoded, scriptManager, enableCdn: enableCdn);
|
|
}
|
|
|
|
/// <devdoc>
|
|
/// Gets a URL resource reference to a client-side resource
|
|
/// </devdoc>
|
|
internal static string GetWebResourceUrl(Type type, string resourceName, bool htmlEncoded, IScriptManager scriptManager, bool enableCdn) {
|
|
Assembly assembly = GetAssemblyFromType(type);
|
|
Debug.Assert(assembly != null, "Type.Assembly should never be null.");
|
|
|
|
// If the resource request is for System.Web.dll and more specifically
|
|
// it is for a file that we shipped in v1.x, we have to check if a
|
|
// customized copy of the file exists. See notes at the top of the file
|
|
// regarding this.
|
|
if (assembly == typeof(AssemblyResourceLoader).Assembly) {
|
|
if (String.Equals(resourceName, "WebForms.js", StringComparison.Ordinal)) {
|
|
if (!_webFormsScriptChecked) {
|
|
_webFormsScriptLocation = GetDiskResourcePath(resourceName);
|
|
_webFormsScriptChecked = true;
|
|
}
|
|
if (_webFormsScriptLocation != null) {
|
|
return _webFormsScriptLocation.VirtualPathString;
|
|
}
|
|
}
|
|
else if (String.Equals(resourceName, "WebUIValidation.js", StringComparison.Ordinal)) {
|
|
if (!_webUIValidationScriptChecked) {
|
|
_webUIValidationScriptLocation = GetDiskResourcePath(resourceName);
|
|
_webUIValidationScriptChecked = true;
|
|
}
|
|
if (_webUIValidationScriptLocation != null) {
|
|
return _webUIValidationScriptLocation.VirtualPathString;
|
|
}
|
|
}
|
|
else if (String.Equals(resourceName, "SmartNav.htm", StringComparison.Ordinal)) {
|
|
if (!_smartNavPageChecked) {
|
|
_smartNavPageLocation = GetDiskResourcePath(resourceName);
|
|
_smartNavPageChecked = true;
|
|
}
|
|
if (_smartNavPageLocation != null) {
|
|
return _smartNavPageLocation.VirtualPathString;
|
|
}
|
|
}
|
|
else if (String.Equals(resourceName, "SmartNav.js", StringComparison.Ordinal)) {
|
|
if (!_smartNavScriptChecked) {
|
|
_smartNavScriptLocation = GetDiskResourcePath(resourceName);
|
|
_smartNavScriptChecked = true;
|
|
}
|
|
if (_smartNavScriptLocation != null) {
|
|
return _smartNavScriptLocation.VirtualPathString;
|
|
}
|
|
}
|
|
}
|
|
|
|
return GetWebResourceUrlInternal(assembly, resourceName, htmlEncoded, false, scriptManager, enableCdn);
|
|
}
|
|
|
|
private static WebResourceAttribute FindWebResourceAttribute(Assembly assembly, string resourceName) {
|
|
object[] attrs = assembly.GetCustomAttributes(false);
|
|
for (int i = 0; i < attrs.Length; i++) {
|
|
WebResourceAttribute wra = attrs[i] as WebResourceAttribute;
|
|
if ((wra != null) && String.Equals(wra.WebResource, resourceName, StringComparison.Ordinal)) {
|
|
return wra;
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
|
|
internal static string FormatCdnUrl(Assembly assembly, string cdnPath) {
|
|
// {0} = Short Assembly Name
|
|
// {1} = Assembly Version
|
|
// {2} = Assembly File Version
|
|
// use a new AssemblyName because assembly.GetName() doesn't work in medium trust.
|
|
AssemblyName assemblyName = new AssemblyName(assembly.FullName);
|
|
return String.Format(CultureInfo.InvariantCulture,
|
|
cdnPath,
|
|
HttpUtility.UrlEncode(assemblyName.Name),
|
|
HttpUtility.UrlEncode(assemblyName.Version.ToString(4)),
|
|
HttpUtility.UrlEncode(AssemblyUtil.GetAssemblyFileVersion(assembly)));
|
|
}
|
|
|
|
private static string GetCdnPath(string resourceName, Assembly assembly, bool secureConnection) {
|
|
string cdnPath = null;
|
|
WebResourceAttribute wra = FindWebResourceAttribute(assembly, resourceName);
|
|
if (wra != null) {
|
|
cdnPath = secureConnection ? wra.CdnPathSecureConnection : wra.CdnPath;
|
|
if (!String.IsNullOrEmpty(cdnPath)) {
|
|
cdnPath = FormatCdnUrl(assembly, cdnPath);
|
|
}
|
|
}
|
|
return cdnPath;
|
|
}
|
|
|
|
internal static string GetWebResourceUrlInternal(Assembly assembly, string resourceName,
|
|
bool htmlEncoded, bool forSubstitution, IScriptManager scriptManager) {
|
|
|
|
bool enableCdn = (scriptManager != null && scriptManager.EnableCdn);
|
|
return GetWebResourceUrlInternal(assembly, resourceName, htmlEncoded, forSubstitution, scriptManager, enableCdn: enableCdn);
|
|
}
|
|
|
|
internal static string GetWebResourceUrlInternal(Assembly assembly, string resourceName,
|
|
bool htmlEncoded, bool forSubstitution, IScriptManager scriptManager, bool enableCdn) {
|
|
// When this url is being inserted as a substitution in another resource,
|
|
// it should just be "WebResource.axd?d=..." since the resource is already coming
|
|
// from the app root (i.e. no need for a full absolute /app/WebResource.axd).
|
|
// Otherwise we must return a path that is absolute (starts with '/') or
|
|
// a full absolute uri (http://..) as in the case of a CDN Path.
|
|
|
|
EnsureHandlerExistenceChecked();
|
|
if (!_handlerExists) {
|
|
throw new InvalidOperationException(SR.GetString(SR.AssemblyResourceLoader_HandlerNotRegistered));
|
|
}
|
|
Assembly effectiveAssembly = assembly;
|
|
string effectiveResourceName = resourceName;
|
|
|
|
bool debuggingEnabled = false;
|
|
bool secureConnection;
|
|
if (scriptManager != null) {
|
|
debuggingEnabled = scriptManager.IsDebuggingEnabled;
|
|
secureConnection = scriptManager.IsSecureConnection;
|
|
}
|
|
else {
|
|
secureConnection = ((HttpContext.Current != null) && (HttpContext.Current.Request != null) &&
|
|
HttpContext.Current.Request.IsSecureConnection);
|
|
debuggingEnabled = (HttpContext.Current != null) && HttpContext.Current.IsDebuggingEnabled;
|
|
}
|
|
int urlCacheKey = CreateWebResourceUrlCacheKey(assembly, resourceName, htmlEncoded,
|
|
forSubstitution, enableCdn, debuggingEnabled, secureConnection);
|
|
|
|
string url = (string)_urlCache[urlCacheKey];
|
|
|
|
if (url == null) {
|
|
IScriptResourceDefinition definition = null;
|
|
if (ClientScriptManager._scriptResourceMapping != null) {
|
|
definition = ClientScriptManager._scriptResourceMapping.GetDefinition(resourceName, assembly);
|
|
if (definition != null) {
|
|
if (!String.IsNullOrEmpty(definition.ResourceName)) {
|
|
effectiveResourceName = definition.ResourceName;
|
|
}
|
|
if (definition.ResourceAssembly != null) {
|
|
effectiveAssembly = definition.ResourceAssembly;
|
|
}
|
|
}
|
|
}
|
|
string path = null;
|
|
// if a resource mapping exists, take it's settings into consideration
|
|
// it might supply a path or a cdnpath.
|
|
if (definition != null) {
|
|
if (enableCdn) {
|
|
// Winner is first path defined, falling back on the effectiveResourceName/Assembly
|
|
// Debug Mode : d.CdnDebugPath, d.DebugPath, *wra.CdnPath, d.Path
|
|
// Release Mode: d.CdnPath , *wra.CdnPath, d.Path
|
|
// * the WebResourceAttribute corresponding to the resource defined in the definition, not the
|
|
// the original resource.
|
|
// Also, if the definition has a CdnPath but it cannot be converted to a secure one during https,
|
|
// the WRA's CdnPath is not considered.
|
|
if (debuggingEnabled) {
|
|
path = secureConnection ? definition.CdnDebugPathSecureConnection : definition.CdnDebugPath;
|
|
if (String.IsNullOrEmpty(path)) {
|
|
path = definition.DebugPath;
|
|
if (String.IsNullOrEmpty(path)) {
|
|
// Get CDN Path from the redirected resource name/assembly, not the original one,
|
|
// but not if this is a secure connection and the only reason we didn't use the definition
|
|
// cdn path is because it doesnt support secure connections.
|
|
if (!secureConnection || String.IsNullOrEmpty(definition.CdnDebugPath)) {
|
|
path = GetCdnPath(effectiveResourceName, effectiveAssembly, secureConnection);
|
|
}
|
|
if (String.IsNullOrEmpty(path)) {
|
|
path = definition.Path;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else {
|
|
path = secureConnection ? definition.CdnPathSecureConnection : definition.CdnPath;
|
|
if (String.IsNullOrEmpty(path)) {
|
|
// Get CDN Path from the redirected resource name/assembly, not the original one
|
|
// but not if this is a secure connection and the only reason we didn't use the definition
|
|
// cdn path is because it doesnt support secure connections.
|
|
if (!secureConnection || String.IsNullOrEmpty(definition.CdnPath)) {
|
|
path = GetCdnPath(effectiveResourceName, effectiveAssembly, secureConnection);
|
|
}
|
|
if (String.IsNullOrEmpty(path)) {
|
|
path = definition.Path;
|
|
}
|
|
}
|
|
}
|
|
} // cdn
|
|
else {
|
|
// Winner is first path defined, falling back on the effectiveResourceName/Assembly
|
|
// Debug Mode : d.DebugPath, d.Path
|
|
// Release Mode: d.Path
|
|
if (debuggingEnabled) {
|
|
path = definition.DebugPath;
|
|
if (String.IsNullOrEmpty(path)) {
|
|
path = definition.Path;
|
|
}
|
|
}
|
|
else {
|
|
path = definition.Path;
|
|
}
|
|
}
|
|
} // does not have definition
|
|
else if (enableCdn) {
|
|
path = GetCdnPath(effectiveResourceName, effectiveAssembly, secureConnection);
|
|
}
|
|
|
|
if (!String.IsNullOrEmpty(path)) {
|
|
// assembly based resource has been overridden by a path,
|
|
// whether that be a CDN Path or a definition.Path or DebugPath.
|
|
// We must return a path that is absolute (starts with '/') or
|
|
// a full absolute uri (http://..) as in the case of a CDN Path.
|
|
// An overridden Path that is not a CDN Path is required to be absolute
|
|
// or app relative.
|
|
if (UrlPath.IsAppRelativePath(path)) {
|
|
// expand ~/. If it is rooted (/) or an absolute uri, no conversion needed
|
|
if (_applicationRootPath == null) {
|
|
url = VirtualPathUtility.ToAbsolute(path);
|
|
}
|
|
else {
|
|
url = VirtualPathUtility.ToAbsolute(path, _applicationRootPath);
|
|
}
|
|
}
|
|
else {
|
|
// must be a full uri or already rooted.
|
|
url = path;
|
|
}
|
|
if (htmlEncoded) {
|
|
url = HttpUtility.HtmlEncode(url);
|
|
}
|
|
}
|
|
else {
|
|
string urlAssemblyName;
|
|
Pair assemblyInfo = GetAssemblyInfo(effectiveAssembly);
|
|
AssemblyName assemblyName = (AssemblyName)assemblyInfo.First;
|
|
long assemblyDate = (long)assemblyInfo.Second;
|
|
string assemblyVersion = assemblyName.Version.ToString();
|
|
|
|
if (effectiveAssembly.GlobalAssemblyCache) {
|
|
// If the assembly is in the GAC, we need to store a full name to load the assembly later
|
|
if (effectiveAssembly == HttpContext.SystemWebAssembly) {
|
|
urlAssemblyName = "s";
|
|
}
|
|
else {
|
|
// Pack the necessary values into a more compact format than FullName
|
|
StringBuilder builder = new StringBuilder();
|
|
builder.Append('f');
|
|
builder.Append(assemblyName.Name);
|
|
builder.Append(',');
|
|
builder.Append(assemblyVersion);
|
|
builder.Append(',');
|
|
if (assemblyName.CultureInfo != null) {
|
|
builder.Append(assemblyName.CultureInfo.ToString());
|
|
}
|
|
builder.Append(',');
|
|
byte[] token = assemblyName.GetPublicKeyToken();
|
|
for (int i = 0; i < token.Length; i++) {
|
|
builder.Append(token[i].ToString("x2", CultureInfo.InvariantCulture));
|
|
}
|
|
urlAssemblyName = builder.ToString();
|
|
}
|
|
}
|
|
else {
|
|
// Otherwise, we can just use a partial name
|
|
urlAssemblyName = "p" + assemblyName.Name;
|
|
}
|
|
url = FormatWebResourceUrl(urlAssemblyName, effectiveResourceName, assemblyDate, htmlEncoded);
|
|
if (!forSubstitution && (HttpRuntime.AppDomainAppVirtualPathString != null)) {
|
|
// When this url is being inserted as a substitution in another resource,
|
|
// it should just be "WebResource.axd?d=..." since the resource is already coming
|
|
// from the app root (i.e. no need for a full absolute /app/WebResource.axd).
|
|
url = UrlPath.Combine(HttpRuntime.AppDomainAppVirtualPathString, url);
|
|
}
|
|
}
|
|
_urlCache[urlCacheKey] = url;
|
|
}
|
|
return url;
|
|
}
|
|
|
|
internal static bool IsValidWebResourceRequest(HttpContext context) {
|
|
EnsureHandlerExistenceChecked();
|
|
if (!_handlerExists) {
|
|
// If the handler isn't properly registered, it can't
|
|
// possibly be a valid web resource request.
|
|
return false;
|
|
}
|
|
|
|
string webResourceHandlerUrl = UrlPath.Combine(HttpRuntime.AppDomainAppVirtualPathString, _webResourceUrl);
|
|
string requestPath = context.Request.Path;
|
|
if (String.Equals(requestPath, webResourceHandlerUrl, StringComparison.OrdinalIgnoreCase)) {
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
internal static void LogWebResourceFailure(string decryptedData, Exception exception) {
|
|
string errorMessage = null;
|
|
if (decryptedData != null) {
|
|
errorMessage = SR.GetString(SR.Webevent_msg_RuntimeErrorWebResourceFailure_ResourceMissing, decryptedData);
|
|
}
|
|
else {
|
|
errorMessage = SR.GetString(SR.Webevent_msg_RuntimeErrorWebResourceFailure_DecryptionError);
|
|
}
|
|
WebBaseEvent.RaiseSystemEvent(message: errorMessage,
|
|
source: null,
|
|
eventCode: WebEventCodes.RuntimeErrorWebResourceFailure,
|
|
eventDetailCode: WebEventCodes.UndefinedEventDetailCode,
|
|
exception: exception);
|
|
}
|
|
|
|
/// <internalonly/>
|
|
bool IHttpHandler.IsReusable {
|
|
get {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
|
|
/// <internalonly/>
|
|
void IHttpHandler.ProcessRequest(HttpContext context) {
|
|
// Make sure we don't get any extra content in this handler (like Application.BeginRequest stuff);
|
|
context.Response.Clear();
|
|
|
|
Stream resourceStream = null;
|
|
string decryptedData = null;
|
|
bool resourceIdentifierPresent = false;
|
|
|
|
Exception exception = null;
|
|
try {
|
|
NameValueCollection queryString = context.Request.QueryString;
|
|
|
|
string encryptedData = queryString["d"];
|
|
if (String.IsNullOrEmpty(encryptedData)) {
|
|
throw new HttpException(404, SR.GetString(SR.AssemblyResourceLoader_InvalidRequest));
|
|
}
|
|
resourceIdentifierPresent = true;
|
|
|
|
decryptedData = Page.DecryptString(encryptedData, Purpose.AssemblyResourceLoader_WebResourceUrl);
|
|
|
|
int separatorIndex = decryptedData.IndexOf('|');
|
|
Debug.Assert(separatorIndex != -1, "The decrypted data must contain a separator.");
|
|
|
|
string assemblyName = decryptedData.Substring(0, separatorIndex);
|
|
if (String.IsNullOrEmpty(assemblyName)) {
|
|
throw new HttpException(404, SR.GetString(SR.AssemblyResourceLoader_AssemblyNotFound, assemblyName));
|
|
}
|
|
|
|
string resourceName = decryptedData.Substring(separatorIndex + 1);
|
|
if (String.IsNullOrEmpty(resourceName)) {
|
|
throw new HttpException(404, SR.GetString(SR.AssemblyResourceLoader_ResourceNotFound, resourceName));
|
|
}
|
|
|
|
char nameType = assemblyName[0];
|
|
assemblyName = assemblyName.Substring(1);
|
|
|
|
Assembly assembly = null;
|
|
|
|
// If it was a full name, create an AssemblyName and load from that
|
|
if (nameType == 'f') {
|
|
string[] parts = assemblyName.Split(',');
|
|
|
|
if (parts.Length != 4) {
|
|
throw new HttpException(404, SR.GetString(SR.AssemblyResourceLoader_InvalidRequest));
|
|
}
|
|
|
|
AssemblyName realName = new AssemblyName();
|
|
realName.Name = parts[0];
|
|
realName.Version = new Version(parts[1]);
|
|
string cultureString = parts[2];
|
|
|
|
// Try to determine the culture, using the invariant culture if there wasn't one (doesn't work without it)
|
|
if (cultureString.Length > 0) {
|
|
realName.CultureInfo = new CultureInfo(cultureString);
|
|
}
|
|
else {
|
|
realName.CultureInfo = CultureInfo.InvariantCulture;
|
|
}
|
|
|
|
// Parse up the public key token which is represented as hex bytes in a string
|
|
string token = parts[3];
|
|
byte[] tokenBytes = new byte[token.Length / 2];
|
|
for (int i = 0; i < tokenBytes.Length; i++) {
|
|
tokenBytes[i] = Byte.Parse(token.Substring(i * 2, 2), NumberStyles.HexNumber, CultureInfo.InvariantCulture);
|
|
}
|
|
realName.SetPublicKeyToken(tokenBytes);
|
|
|
|
assembly = Assembly.Load(realName);
|
|
}
|
|
// System.Web special case
|
|
else if (nameType == 's') {
|
|
assembly = typeof(AssemblyResourceLoader).Assembly;
|
|
}
|
|
// If was a partial name, just try to load it
|
|
else if (nameType == 'p') {
|
|
assembly = Assembly.Load(assemblyName);
|
|
}
|
|
else {
|
|
throw new HttpException(404, SR.GetString(SR.AssemblyResourceLoader_InvalidRequest));
|
|
}
|
|
|
|
// Dev10 Bugs 602949: Throw 404 if resource not found rather than do nothing.
|
|
// This is done before creating the cache entry, since it could be that the assembly is loaded
|
|
// later on without the app restarting.
|
|
if (assembly == null) {
|
|
throw new HttpException(404, SR.GetString(SR.AssemblyResourceLoader_InvalidRequest));
|
|
}
|
|
|
|
bool performSubstitution = false;
|
|
bool validResource = false;
|
|
string contentType = String.Empty;
|
|
|
|
// Check the validation cache to see if the resource has already been validated
|
|
int cacheKey = HashCodeCombiner.CombineHashCodes(assembly.GetHashCode(), resourceName.GetHashCode());
|
|
Triplet resourceTriplet = (Triplet)_webResourceCache[cacheKey];
|
|
if (resourceTriplet != null) {
|
|
validResource = (bool)resourceTriplet.First;
|
|
contentType = (string)resourceTriplet.Second;
|
|
performSubstitution = (bool)resourceTriplet.Third;
|
|
}
|
|
else {
|
|
// Validation cache is empty, find out if it's valid and add it to the cache
|
|
WebResourceAttribute wra = FindWebResourceAttribute(assembly, resourceName);
|
|
if (wra != null) {
|
|
resourceName = wra.WebResource;
|
|
validResource = true;
|
|
contentType = wra.ContentType;
|
|
performSubstitution = wra.PerformSubstitution;
|
|
}
|
|
|
|
// Cache the result so we don't have to do this again
|
|
try {
|
|
if (validResource) {
|
|
// a WebResourceAttribute was found, but does the resource really exist?
|
|
validResource = false;
|
|
resourceStream = assembly.GetManifestResourceStream(resourceName);
|
|
validResource = (resourceStream != null);
|
|
}
|
|
}
|
|
finally {
|
|
// Cache the results, even if there was an exception getting the stream,
|
|
// so we don't have to do this again
|
|
Triplet triplet = new Triplet();
|
|
triplet.First = validResource;
|
|
triplet.Second = contentType;
|
|
triplet.Third = performSubstitution;
|
|
_webResourceCache[cacheKey] = triplet;
|
|
}
|
|
}
|
|
|
|
if (validResource) {
|
|
// Cache the resource so we don't keep processing the same requests
|
|
HttpCachePolicy cachePolicy = context.Response.Cache;
|
|
cachePolicy.SetCacheability(HttpCacheability.Public);
|
|
cachePolicy.VaryByParams["d"] = true;
|
|
cachePolicy.SetOmitVaryStar(true);
|
|
cachePolicy.SetExpires(DateTime.Now + TimeSpan.FromDays(365));
|
|
cachePolicy.SetValidUntilExpires(true);
|
|
Pair assemblyInfo = GetAssemblyInfo(assembly);
|
|
cachePolicy.SetLastModified(new DateTime((long)assemblyInfo.Second));
|
|
|
|
StreamReader reader = null;
|
|
try {
|
|
if (resourceStream == null) {
|
|
// null in the case that _webResourceCache had the item
|
|
resourceStream = assembly.GetManifestResourceStream(resourceName);
|
|
}
|
|
if (resourceStream != null) {
|
|
context.Response.ContentType = contentType;
|
|
|
|
if (performSubstitution) {
|
|
//
|
|
reader = new StreamReader(resourceStream, true);
|
|
|
|
string content = reader.ReadToEnd();
|
|
|
|
// Looking for something of the form: WebResource("resourcename")
|
|
MatchCollection matches = webResourceRegex.Matches(content);
|
|
int startIndex = 0;
|
|
StringBuilder newContent = new StringBuilder();
|
|
foreach (Match match in matches) {
|
|
newContent.Append(content.Substring(startIndex, match.Index - startIndex));
|
|
|
|
Group group = match.Groups["resourceName"];
|
|
if (group != null) {
|
|
string embeddedResourceName = group.ToString();
|
|
if (embeddedResourceName.Length > 0) {
|
|
//
|
|
if (String.Equals(embeddedResourceName, resourceName, StringComparison.Ordinal)) {
|
|
throw new HttpException(404, SR.GetString(SR.AssemblyResourceLoader_NoCircularReferences, resourceName));
|
|
}
|
|
newContent.Append(GetWebResourceUrlInternal(assembly, embeddedResourceName, htmlEncoded: false, forSubstitution: true, scriptManager: null));
|
|
}
|
|
}
|
|
|
|
startIndex = match.Index + match.Length;
|
|
}
|
|
|
|
newContent.Append(content.Substring(startIndex, content.Length - startIndex));
|
|
|
|
StreamWriter writer = new StreamWriter(context.Response.OutputStream, reader.CurrentEncoding);
|
|
writer.Write(newContent.ToString());
|
|
writer.Flush();
|
|
}
|
|
else {
|
|
byte[] buffer = new byte[1024];
|
|
Stream outputStream = context.Response.OutputStream;
|
|
int count = 1;
|
|
while (count > 0) {
|
|
count = resourceStream.Read(buffer, 0, 1024);
|
|
outputStream.Write(buffer, 0, count);
|
|
}
|
|
outputStream.Flush();
|
|
}
|
|
}
|
|
}
|
|
finally {
|
|
if (reader != null)
|
|
reader.Close();
|
|
if (resourceStream != null)
|
|
resourceStream.Close();
|
|
}
|
|
}
|
|
}
|
|
catch(Exception e) {
|
|
exception = e;
|
|
// MSRC 10405: ---- all errors in the event of failure. In particular, we don't want to
|
|
// bubble the inner exceptions up in the YSOD, as they might contain sensitive cryptographic
|
|
// information. Setting 'resourceStream' to null will cause an appropriate exception to
|
|
// be thrown.
|
|
resourceStream = null;
|
|
}
|
|
|
|
// Dev10 Bugs 602949: 404 if the assembly is not found or if the resource does not exist
|
|
if (resourceStream == null) {
|
|
if (resourceIdentifierPresent) {
|
|
LogWebResourceFailure(decryptedData, exception);
|
|
}
|
|
throw new HttpException(404, SR.GetString(SR.AssemblyResourceLoader_InvalidRequest));
|
|
}
|
|
|
|
context.Response.IgnoreFurtherWrites();
|
|
}
|
|
}
|
|
}
|