mirror of https://github.com/SixLabors/ImageSharp
James South
13 years ago
7 changed files with 1060 additions and 193 deletions
@ -0,0 +1,64 @@ |
|||||
|
// License: CPOL at http://www.codeproject.com/info/cpol10.aspx
|
||||
|
using System.Collections.Generic; |
||||
|
using System.Net; |
||||
|
using System.Threading; |
||||
|
using System.Threading.Tasks; |
||||
|
|
||||
|
namespace System.IO |
||||
|
{ |
||||
|
public static class AsyncIoExtensions |
||||
|
{ |
||||
|
public static Task<Stream> GetRequestStreamAsync(this WebRequest webRequest) |
||||
|
{ |
||||
|
return Task.Factory.FromAsync( |
||||
|
webRequest.BeginGetRequestStream, |
||||
|
ar => webRequest.EndGetRequestStream(ar), |
||||
|
null); |
||||
|
} |
||||
|
|
||||
|
public static Task<WebResponse> GetResponseAsync(this WebRequest webRequest) |
||||
|
{ |
||||
|
return Task.Factory.FromAsync( |
||||
|
webRequest.BeginGetResponse, |
||||
|
ar => webRequest.EndGetResponse(ar), |
||||
|
null); |
||||
|
} |
||||
|
|
||||
|
public static Task<int> ReadAsync(this Stream input, Byte[] buffer, int offset, int count) |
||||
|
{ |
||||
|
return Task.Factory.FromAsync( |
||||
|
input.BeginRead, |
||||
|
(Func<IAsyncResult, int>)input.EndRead, |
||||
|
buffer, offset, count, |
||||
|
null); |
||||
|
} |
||||
|
|
||||
|
public static Task WriteAsync(this Stream input, Byte[] buffer, int offset, int count) |
||||
|
{ |
||||
|
return Task.Factory.FromAsync( |
||||
|
input.BeginWrite, |
||||
|
input.EndWrite, |
||||
|
buffer, offset, count, |
||||
|
null); |
||||
|
} |
||||
|
|
||||
|
public static /*async*/ Task CopyToAsync(this Stream input, Stream output, CancellationToken cancellationToken = default(CancellationToken)) |
||||
|
{ |
||||
|
return CopyToAsyncTasks(input, output, cancellationToken).ToTask(); |
||||
|
} |
||||
|
private static IEnumerable<Task> CopyToAsyncTasks(Stream input, Stream output, CancellationToken cancellationToken) |
||||
|
{ |
||||
|
byte[] buffer = new byte[0x1000]; // 4 KiB
|
||||
|
while (true) |
||||
|
{ |
||||
|
cancellationToken.ThrowIfCancellationRequested(); |
||||
|
var readTask = input.ReadAsync(buffer, 0, buffer.Length); |
||||
|
yield return readTask; |
||||
|
if (readTask.Result == 0) break; |
||||
|
|
||||
|
cancellationToken.ThrowIfCancellationRequested(); |
||||
|
yield return output.WriteAsync(buffer, 0, readTask.Result); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
@ -0,0 +1,347 @@ |
|||||
|
// -----------------------------------------------------------------------
|
||||
|
// <copyright file="RemoteFile.cs" company="James South">
|
||||
|
// Copyright (c) James South.
|
||||
|
// Dual licensed under the MIT or GPL Version 2 licenses.
|
||||
|
// </copyright>
|
||||
|
// -----------------------------------------------------------------------
|
||||
|
|
||||
|
namespace ImageProcessor.Web.Helpers |
||||
|
{ |
||||
|
#region Using
|
||||
|
using System; |
||||
|
using System.Diagnostics.Contracts; |
||||
|
using System.Globalization; |
||||
|
using System.IO; |
||||
|
using System.Linq; |
||||
|
using System.Net; |
||||
|
using System.Security; |
||||
|
using System.Text; |
||||
|
using ImageProcessor.Web.Config; |
||||
|
#endregion
|
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Encapsulates methods used to download files from a website address.
|
||||
|
/// </summary>
|
||||
|
/// <remarks>
|
||||
|
/// <para>
|
||||
|
/// The purpose of this class is so there's one core way of downloading remote files with url[s] that are from
|
||||
|
/// outside users. There's various areas in application where an attacker could supply an external url to the server
|
||||
|
/// and tie up resources.
|
||||
|
/// </para>
|
||||
|
/// For example, the ImageProcessingModule accepts off-server addresses as a path. An attacker could, for instance, pass the url
|
||||
|
/// to a file that's a few gigs in size, causing the server to get out-of-memory exceptions or some other errors. An attacker
|
||||
|
/// could also use this same method to use one application instance to hammer another site by, again, passing an off-server
|
||||
|
/// address of the victims site to the ImageProcessingModule.
|
||||
|
/// This class will not throw an exception if the Uri supplied points to a resource local to the running application instance.
|
||||
|
/// <para>
|
||||
|
/// There shouldn't be any security issues there, as the internal WebRequest instance is still calling it remotely.
|
||||
|
/// Any local files that shouldn't be accessed by this won't be allowed by the remote call.
|
||||
|
/// </para>
|
||||
|
/// Adapted from <see cref="http://blogengine.codeplex.com">BlogEngine.Net</see>
|
||||
|
/// </remarks>
|
||||
|
internal sealed class RemoteFile |
||||
|
{ |
||||
|
#region Fields
|
||||
|
/// <summary>
|
||||
|
/// The white-list of url[s] from which to download remote files.
|
||||
|
/// </summary>
|
||||
|
private static readonly Uri[] RemoteFileWhiteList = ImageProcessorConfig.Instance.RemoteFileWhiteList; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The length of time, in milliseconds, that a remote file download attempt can last before timing out.
|
||||
|
/// </summary>
|
||||
|
private static readonly int TimeoutMilliseconds = ImageProcessorConfig.Instance.Timeout; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The maximum size, in bytes, that a remote file download attempt can download.
|
||||
|
/// </summary>
|
||||
|
private static readonly int MaxBytes = ImageProcessorConfig.Instance.MaxBytes; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Whether to allow remote downloads.
|
||||
|
/// </summary>
|
||||
|
private static readonly bool AllowRemoteDownloads = ImageProcessorConfig.Instance.AllowRemoteDownloads; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Whether this RemoteFile instance is ignoring remote download rules set in the current application
|
||||
|
/// instance.
|
||||
|
/// </summary>
|
||||
|
private readonly bool ignoreRemoteDownloadSettings; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The <see cref="T:System.Uri">Uri</see> of the remote file being downloaded.
|
||||
|
/// </summary>
|
||||
|
private readonly Uri url; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The maximum allowable download size in bytes.
|
||||
|
/// </summary>
|
||||
|
private readonly int maxDownloadSize; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The length of time, in milliseconds, that a remote file download attempt can last before timing out.
|
||||
|
/// </summary>
|
||||
|
private int timeoutLength; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The <see cref="T:System.Net.WebResponse">WebResponse</see> object used internally for this RemoteFile instance.
|
||||
|
/// </summary>
|
||||
|
private WebRequest webRequest; |
||||
|
#endregion
|
||||
|
|
||||
|
#region Constructors
|
||||
|
/// <summary>
|
||||
|
/// Initializes a new instance of the <see cref="T:ImageProcessor.Web.Helpers.RemoteFile">RemoteFile</see> class.
|
||||
|
/// </summary>
|
||||
|
/// <param name="filePath">The url of the file to be downloaded.</param>
|
||||
|
/// <param name="ignoreRemoteDownloadSettings">
|
||||
|
/// If set to <see langword="true"/>, then RemoteFile should ignore the current the applications instance's remote download settings; otherwise,<see langword="false"/>.
|
||||
|
/// </param>
|
||||
|
internal RemoteFile(Uri filePath, bool ignoreRemoteDownloadSettings) |
||||
|
{ |
||||
|
Contract.Requires(filePath != null); |
||||
|
|
||||
|
this.url = filePath; |
||||
|
this.ignoreRemoteDownloadSettings = ignoreRemoteDownloadSettings; |
||||
|
this.timeoutLength = TimeoutMilliseconds; |
||||
|
this.maxDownloadSize = MaxBytes; |
||||
|
} |
||||
|
#endregion
|
||||
|
|
||||
|
#region Properties
|
||||
|
/// <summary>
|
||||
|
/// Gets a value indicating whether this RemoteFile instance is ignoring remote download rules set in the
|
||||
|
/// current application instance.
|
||||
|
/// <remarks>
|
||||
|
/// This should only be set to true if the supplied url is a verified resource. Use at your own risk.
|
||||
|
/// </remarks>
|
||||
|
/// </summary>
|
||||
|
/// <value>
|
||||
|
/// <see langword="true"/> if this RemoteFile instance is ignoring remote download rules set in the current
|
||||
|
/// application instance; otherwise, <see langword="false"/>.
|
||||
|
/// </value>
|
||||
|
public bool IgnoreRemoteDownloadSettings |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
return this.ignoreRemoteDownloadSettings; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets the Uri of the remote file being downloaded.
|
||||
|
/// </summary>
|
||||
|
public Uri Uri |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
return this.url; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets or sets the length of time, in milliseconds, that a remote file download attempt can
|
||||
|
/// last before timing out.
|
||||
|
/// <remarks>
|
||||
|
/// <para>
|
||||
|
/// This value can only be set if the instance is supposed to ignore the remote download settings set
|
||||
|
/// in the current application instance.
|
||||
|
/// </para>
|
||||
|
/// <para>
|
||||
|
/// Set this value to 0 if there should be no timeout.
|
||||
|
/// </para>
|
||||
|
/// </remarks>
|
||||
|
/// </summary>
|
||||
|
public int TimeoutLength |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
return this.IgnoreRemoteDownloadSettings ? this.timeoutLength : TimeoutMilliseconds; |
||||
|
} |
||||
|
|
||||
|
set |
||||
|
{ |
||||
|
if (!this.IgnoreRemoteDownloadSettings) |
||||
|
{ |
||||
|
throw new SecurityException("Timeout length can not be adjusted on remote files that are abiding by remote download rules"); |
||||
|
} |
||||
|
|
||||
|
if (value < 0) |
||||
|
{ |
||||
|
throw new ArgumentOutOfRangeException("TimeoutLength"); |
||||
|
} |
||||
|
|
||||
|
this.timeoutLength = value; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Gets or sets the maximum download size, in bytes, that a remote file download attempt can be.
|
||||
|
/// <remarks>
|
||||
|
/// <para>
|
||||
|
/// This value can only be set if the instance is supposed to ignore the remote download settings set
|
||||
|
/// in the current application instance.
|
||||
|
/// </para>
|
||||
|
/// <para>
|
||||
|
/// Set this value to 0 if there should be no timeout.
|
||||
|
/// </para>
|
||||
|
/// </remarks>
|
||||
|
/// </summary>
|
||||
|
public int MaxDownloadSize |
||||
|
{ |
||||
|
get |
||||
|
{ |
||||
|
return this.IgnoreRemoteDownloadSettings ? this.maxDownloadSize : MaxBytes; |
||||
|
} |
||||
|
|
||||
|
set |
||||
|
{ |
||||
|
if (!this.IgnoreRemoteDownloadSettings) |
||||
|
{ |
||||
|
throw new SecurityException("Max Download Size can not be adjusted on remote files that are abiding by remote download rules"); |
||||
|
} |
||||
|
|
||||
|
if (value < 0) |
||||
|
{ |
||||
|
throw new ArgumentOutOfRangeException("MaxDownloadSize"); |
||||
|
} |
||||
|
|
||||
|
this.timeoutLength = value; |
||||
|
} |
||||
|
} |
||||
|
#endregion
|
||||
|
|
||||
|
#region Methods
|
||||
|
#region Public
|
||||
|
/// <summary>
|
||||
|
/// Returns the <see cref="T:System.Net.WebResponse">WebResponse</see> used to download this file.
|
||||
|
/// <remarks>
|
||||
|
/// <para>
|
||||
|
/// This method is meant for outside users who need specific access to the WebResponse this class
|
||||
|
/// generates. They're responsible for disposing of it.
|
||||
|
/// </para>
|
||||
|
/// </remarks>
|
||||
|
/// </summary>
|
||||
|
/// <returns>The <see cref="T:System.Net.WebResponse">WebResponse</see> used to download this file.</returns>
|
||||
|
public WebResponse GetWebResponse() |
||||
|
{ |
||||
|
WebResponse response = this.GetWebRequest().GetResponse(); |
||||
|
|
||||
|
long contentLength = response.ContentLength; |
||||
|
|
||||
|
// WebResponse.ContentLength doesn't always know the value, it returns -1 in this case.
|
||||
|
if (contentLength == -1) |
||||
|
{ |
||||
|
// Response headers may still have the Content-Length inside of it.
|
||||
|
string headerContentLength = response.Headers["Content-Length"]; |
||||
|
|
||||
|
if (!string.IsNullOrWhiteSpace(headerContentLength)) |
||||
|
{ |
||||
|
contentLength = long.Parse(headerContentLength, CultureInfo.InvariantCulture); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
// We don't need to check the url here since any external urls are available only from the web.config.
|
||||
|
if ((this.MaxDownloadSize > 0) && (contentLength > this.MaxDownloadSize)) |
||||
|
{ |
||||
|
response.Close(); |
||||
|
throw new SecurityException("An attempt to download a remote file has been halted because the file is larger than allowed."); |
||||
|
} |
||||
|
|
||||
|
return response; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns the remote file as a String.
|
||||
|
/// <remarks>
|
||||
|
/// This returns the resulting stream as a string as passed through a StreamReader.
|
||||
|
/// </remarks>
|
||||
|
/// </summary>
|
||||
|
/// <returns>The remote file as a String.</returns>
|
||||
|
public string GetFileAsString() |
||||
|
{ |
||||
|
using (WebResponse response = this.GetWebResponse()) |
||||
|
{ |
||||
|
Stream responseStream = response.GetResponseStream(); |
||||
|
|
||||
|
if (responseStream != null) |
||||
|
{ |
||||
|
// Pipe the stream to a stream reader with the required encoding format.
|
||||
|
using (StreamReader reader = new StreamReader(responseStream, Encoding.UTF8)) |
||||
|
{ |
||||
|
return reader.ReadToEnd(); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
return string.Empty; |
||||
|
} |
||||
|
} |
||||
|
#endregion
|
||||
|
|
||||
|
#region Private
|
||||
|
/// <summary>
|
||||
|
/// Performs a check to see whether the application is able to download remote files.
|
||||
|
/// </summary>
|
||||
|
private void CheckCanDownload() |
||||
|
{ |
||||
|
if (!this.IgnoreRemoteDownloadSettings && !AllowRemoteDownloads) |
||||
|
{ |
||||
|
throw new SecurityException("application is not configured to allow remote file downloads."); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Creates the WebRequest object used internally for this RemoteFile instance.
|
||||
|
/// </summary>
|
||||
|
/// <returns>
|
||||
|
/// <para>
|
||||
|
/// The WebRequest should not be passed outside of this instance, as it will allow tampering. Anyone
|
||||
|
/// that needs more fine control over the downloading process should probably be using the WebRequest
|
||||
|
/// class on its own.
|
||||
|
/// </para>
|
||||
|
/// </returns>
|
||||
|
private WebRequest GetWebRequest() |
||||
|
{ |
||||
|
// Check downloads are allowed.
|
||||
|
this.CheckCanDownload(); |
||||
|
|
||||
|
// Check the url is from a whitelisted location.
|
||||
|
this.CheckSafeUrlLocation(); |
||||
|
|
||||
|
if (this.webRequest == null) |
||||
|
{ |
||||
|
HttpWebRequest request = (HttpWebRequest)WebRequest.Create(this.Uri); |
||||
|
request.Headers["Accept-Encoding"] = "gzip"; |
||||
|
request.Headers["Accept-Language"] = "en-us"; |
||||
|
request.Credentials = CredentialCache.DefaultNetworkCredentials; |
||||
|
request.AutomaticDecompression = DecompressionMethods.GZip; |
||||
|
|
||||
|
if (this.TimeoutLength > 0) |
||||
|
{ |
||||
|
request.Timeout = this.TimeoutLength; |
||||
|
} |
||||
|
|
||||
|
this.webRequest = request; |
||||
|
} |
||||
|
|
||||
|
return this.webRequest; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Returns a value indicating whether the current url is in a list of safe download locations.
|
||||
|
/// </summary>
|
||||
|
private void CheckSafeUrlLocation() |
||||
|
{ |
||||
|
bool validUrl = RemoteFileWhiteList.Any(item => item.Host.ToUpperInvariant().Equals(this.url.Host.ToUpperInvariant())); |
||||
|
|
||||
|
if (!validUrl) |
||||
|
{ |
||||
|
throw new SecurityException("application is not configured to allow remote file downloads from this domain."); |
||||
|
} |
||||
|
} |
||||
|
#endregion
|
||||
|
#endregion
|
||||
|
} |
||||
|
} |
||||
|
|
||||
|
|
||||
@ -0,0 +1,342 @@ |
|||||
|
// -----------------------------------------------------------------------
|
||||
|
// <copyright file="ImageProcessingModule.cs" company="James South">
|
||||
|
// Copyright (c) James South.
|
||||
|
// Dual licensed under the MIT or GPL Version 2 licenses.
|
||||
|
// </copyright>
|
||||
|
// -----------------------------------------------------------------------
|
||||
|
|
||||
|
namespace ImageProcessor.Web.HttpModules |
||||
|
{ |
||||
|
#region Using
|
||||
|
using System; |
||||
|
using System.IO; |
||||
|
using System.Net; |
||||
|
using System.Reflection; |
||||
|
using System.Web; |
||||
|
using System.Web.Hosting; |
||||
|
using ImageProcessor.Helpers.Extensions; |
||||
|
using ImageProcessor.Imaging; |
||||
|
using ImageProcessor.Web.Caching; |
||||
|
using ImageProcessor.Web.Config; |
||||
|
using ImageProcessor.Web.Helpers; |
||||
|
#endregion
|
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Processes any image requests within the web application.
|
||||
|
/// </summary>
|
||||
|
public class ImageProcessingModule : IHttpModule |
||||
|
{ |
||||
|
#region Fields
|
||||
|
/// <summary>
|
||||
|
/// The key for storing the response type of the current image.
|
||||
|
/// </summary>
|
||||
|
private const string CachedResponseTypeKey = "CACHED_IMAGE_RESPONSE_TYPE"; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The value to prefix any remote image requests with to ensure they get captured.
|
||||
|
/// </summary>
|
||||
|
private static readonly string RemotePrefix = ImageProcessorConfig.Instance.RemotePrefix; |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The object to lock against.
|
||||
|
/// </summary>
|
||||
|
private static readonly object SyncRoot = new object(); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The assembly version.
|
||||
|
/// </summary>
|
||||
|
private static readonly string AssemblyVersion = Assembly.GetExecutingAssembly().GetName().Version.ToString(); |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// A value indicating whether the application has started.
|
||||
|
/// </summary>
|
||||
|
private static bool hasModuleInitialized; |
||||
|
#endregion
|
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The delegate void representing the ProcessImage method.
|
||||
|
/// </summary>
|
||||
|
/// <param name="context">
|
||||
|
/// the <see cref="T:System.Web.HttpContext">HttpContext</see> object that provides
|
||||
|
/// references to the intrinsic server objects
|
||||
|
/// </param>
|
||||
|
private delegate void ProcessImageDelegate(HttpContext context); |
||||
|
|
||||
|
#region IHttpModule Members
|
||||
|
/// <summary>
|
||||
|
/// Initializes a module and prepares it to handle requests.
|
||||
|
/// </summary>
|
||||
|
/// <param name="context">
|
||||
|
/// An <see cref="T:System.Web.HttpApplication"/> that provides
|
||||
|
/// access to the methods, properties, and events common to all
|
||||
|
/// application objects within an ASP.NET application
|
||||
|
/// </param>
|
||||
|
public void Init(HttpApplication context) |
||||
|
{ |
||||
|
if (!hasModuleInitialized) |
||||
|
{ |
||||
|
lock (SyncRoot) |
||||
|
{ |
||||
|
if (!hasModuleInitialized) |
||||
|
{ |
||||
|
DiskCache.CreateCacheDirectories(); |
||||
|
hasModuleInitialized = true; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
context.AddOnBeginRequestAsync(this.OnBeginAsync, this.OnEndAsync); |
||||
|
context.PreSendRequestHeaders += this.ContextPreSendRequestHeaders; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Disposes of the resources (other than memory) used by the module that implements <see cref="T:System.Web.IHttpModule"/>.
|
||||
|
/// </summary>
|
||||
|
public void Dispose() |
||||
|
{ |
||||
|
// Nothing to dispose.
|
||||
|
} |
||||
|
#endregion
|
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The <see cref="T:System.Web.BeginEventHandler"/> that starts asynchronous processing
|
||||
|
/// of the <see cref="System.Web.HttpApplication.BeginRequest"/>.
|
||||
|
/// </summary>
|
||||
|
/// <param name="sender">The source of the event.</param>
|
||||
|
/// <param name="e">
|
||||
|
/// An <see cref="T:System.EventArgs">EventArgs</see> that contains
|
||||
|
/// the event data.
|
||||
|
/// </param>
|
||||
|
/// <param name="callBack">
|
||||
|
/// The delegate to call when the asynchronous method call is complete.
|
||||
|
/// If the callback is null, the delegate is not called.
|
||||
|
/// </param>
|
||||
|
/// <param name="state">
|
||||
|
/// Any additional data needed to process the request.
|
||||
|
/// </param>
|
||||
|
/// <returns>
|
||||
|
/// The status of the asynchronous operation.
|
||||
|
/// </returns>
|
||||
|
private IAsyncResult OnBeginAsync(object sender, EventArgs e, AsyncCallback callBack, object state) |
||||
|
{ |
||||
|
HttpContext context = ((HttpApplication)sender).Context; |
||||
|
|
||||
|
ProcessImageDelegate processImage = this.ProcessImage; |
||||
|
|
||||
|
return processImage.BeginInvoke(context, callBack, state); |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// The method that handles asynchronous events such as application events.
|
||||
|
/// </summary>
|
||||
|
/// <param name="result">
|
||||
|
/// The <see cref="T:System.IAsyncResult"/> that is the result of the
|
||||
|
/// <see cref="T:System.Web.BeginEventHandler"/> operation.
|
||||
|
/// </param>
|
||||
|
private void OnEndAsync(IAsyncResult result) |
||||
|
{ |
||||
|
// Ensure our ProcessImage has completed in the background.
|
||||
|
while (!result.IsCompleted) |
||||
|
{ |
||||
|
System.Threading.Thread.Sleep(1); |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// Occurs just before ASP.NET send HttpHeaders to the client.
|
||||
|
/// </summary>
|
||||
|
/// <param name="sender">The source of the event.</param>
|
||||
|
/// <param name="e">An <see cref="T:System.EventArgs">EventArgs</see> that contains the event data.</param>
|
||||
|
private void ContextPreSendRequestHeaders(object sender, EventArgs e) |
||||
|
{ |
||||
|
HttpContext context = ((HttpApplication)sender).Context; |
||||
|
|
||||
|
object responseTypeObject = context.Items[CachedResponseTypeKey]; |
||||
|
|
||||
|
if (responseTypeObject != null) |
||||
|
{ |
||||
|
string responseType = (string)responseTypeObject; |
||||
|
|
||||
|
// Set the headers
|
||||
|
this.SetHeaders(context, responseType); |
||||
|
|
||||
|
context.Items[CachedResponseTypeKey] = null; |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
#region Private
|
||||
|
/// <summary>
|
||||
|
/// Processes the image.
|
||||
|
/// </summary>
|
||||
|
/// <param name="context">
|
||||
|
/// the <see cref="T:System.Web.HttpContext">HttpContext</see> object that provides
|
||||
|
/// references to the intrinsic server objects
|
||||
|
/// </param>
|
||||
|
private void ProcessImage(HttpContext context) |
||||
|
{ |
||||
|
// Is this a remote file.
|
||||
|
bool isRemote = context.Request.Path.Equals(RemotePrefix, StringComparison.OrdinalIgnoreCase); |
||||
|
string path = string.Empty; |
||||
|
string queryString = string.Empty; |
||||
|
|
||||
|
if (isRemote) |
||||
|
{ |
||||
|
// We need to split the querystring to get the actual values we want.
|
||||
|
string urlDecode = HttpUtility.UrlDecode(context.Request.QueryString.ToString()); |
||||
|
|
||||
|
if (urlDecode != null) |
||||
|
{ |
||||
|
string[] paths = urlDecode.Split('?'); |
||||
|
|
||||
|
path = paths[0]; |
||||
|
|
||||
|
if (paths.Length > 1) |
||||
|
{ |
||||
|
queryString = paths[1]; |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
path = HostingEnvironment.MapPath(context.Request.Path); |
||||
|
queryString = HttpUtility.UrlDecode(context.Request.QueryString.ToString()); |
||||
|
} |
||||
|
|
||||
|
// Only process requests that pass our sanitizing filter.
|
||||
|
if (ImageUtils.IsValidImageExtension(path) && !string.IsNullOrWhiteSpace(queryString)) |
||||
|
{ |
||||
|
if (this.FileExists(path, isRemote)) |
||||
|
{ |
||||
|
string fullPath = string.Format("{0}?{1}", path, queryString); |
||||
|
string imageName = Path.GetFileName(path); |
||||
|
string cachedPath = DiskCache.GetCachePath(fullPath, imageName); |
||||
|
bool isUpdated = DiskCache.IsUpdatedFile(path, cachedPath, isRemote); |
||||
|
|
||||
|
// Only process if the file has been updated.
|
||||
|
if (isUpdated) |
||||
|
{ |
||||
|
// Process the image.
|
||||
|
using (ImageFactory imageFactory = new ImageFactory()) |
||||
|
{ |
||||
|
if (isRemote) |
||||
|
{ |
||||
|
Uri uri = new Uri(path); |
||||
|
RemoteFile remoteFile = new RemoteFile(uri, false); |
||||
|
|
||||
|
using (MemoryStream memoryStream = new MemoryStream()) |
||||
|
{ |
||||
|
using (Stream responseStream = remoteFile.GetWebResponse().GetResponseStream()) |
||||
|
{ |
||||
|
if (responseStream != null) |
||||
|
{ |
||||
|
//lock (SyncRoot)
|
||||
|
//{
|
||||
|
// Trim the cache.
|
||||
|
DiskCache.TrimCachedFolders(); |
||||
|
|
||||
|
responseStream.CopyTo(memoryStream); |
||||
|
|
||||
|
imageFactory.Load(memoryStream) |
||||
|
.AddQueryString(queryString) |
||||
|
.Format(ImageUtils.GetImageFormat(imageName)) |
||||
|
.AutoProcess().Save(cachedPath); |
||||
|
|
||||
|
// Ensure that the LastWriteTime property of the source and cached file match.
|
||||
|
DateTime dateTime = DiskCache.SetCachedLastWriteTime(path, cachedPath, true); |
||||
|
|
||||
|
// Add to the cache.
|
||||
|
DiskCache.AddImageToCache(cachedPath, dateTime); |
||||
|
//}
|
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
else |
||||
|
{ |
||||
|
//lock (SyncRoot)
|
||||
|
//{
|
||||
|
// Trim the cache.
|
||||
|
DiskCache.TrimCachedFolders(); |
||||
|
|
||||
|
imageFactory.Load(fullPath).AutoProcess().Save(cachedPath); |
||||
|
|
||||
|
// Ensure that the LastWriteTime property of the source and cached file match.
|
||||
|
DateTime dateTime = DiskCache.SetCachedLastWriteTime(path, cachedPath, false); |
||||
|
|
||||
|
// Add to the cache.
|
||||
|
DiskCache.AddImageToCache(cachedPath, dateTime); |
||||
|
//}
|
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
context.Items[CachedResponseTypeKey] = ImageUtils.GetResponseType(imageName).ToDescription(); |
||||
|
|
||||
|
// The cached file is valid so just rewrite the path.
|
||||
|
context.RewritePath(DiskCache.GetVirtualPath(cachedPath, context.Request), false); |
||||
|
} |
||||
|
} |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// returns a value indicating whether a file exists.
|
||||
|
/// </summary>
|
||||
|
/// <param name="path">The path to the file to check.</param>
|
||||
|
/// <param name="isRemote">Whether the file is remote.</param>
|
||||
|
/// <returns>True if the file exists, otherwise false.</returns>
|
||||
|
/// <remarks>If the file is remote the method will always return true.</remarks>
|
||||
|
private bool FileExists(string path, bool isRemote) |
||||
|
{ |
||||
|
if (isRemote) |
||||
|
{ |
||||
|
return true; |
||||
|
} |
||||
|
|
||||
|
FileInfo fileInfo = new FileInfo(path); |
||||
|
return fileInfo.Exists; |
||||
|
} |
||||
|
|
||||
|
/// <summary>
|
||||
|
/// This will make the browser and server keep the output
|
||||
|
/// in its cache and thereby improve performance.
|
||||
|
/// See http://en.wikipedia.org/wiki/HTTP_ETag
|
||||
|
/// </summary>
|
||||
|
/// <param name="context">
|
||||
|
/// the <see cref="T:System.Web.HttpContext">HttpContext</see> object that provides
|
||||
|
/// references to the intrinsic server objects
|
||||
|
/// </param>
|
||||
|
/// <param name="responseType">The HTTP MIME type to to send.</param>
|
||||
|
private void SetHeaders(HttpContext context, string responseType) |
||||
|
{ |
||||
|
HttpResponse response = context.Response; |
||||
|
|
||||
|
response.ContentType = responseType; |
||||
|
|
||||
|
response.AddHeader("Image-Served-By", "ImageProcessor/" + AssemblyVersion); |
||||
|
|
||||
|
HttpCachePolicy cache = response.Cache; |
||||
|
|
||||
|
cache.VaryByHeaders["Accept-Encoding"] = true; |
||||
|
|
||||
|
int maxDays = DiskCache.MaxFileCachedDuration; |
||||
|
|
||||
|
cache.SetExpires(DateTime.Now.ToUniversalTime().AddDays(maxDays)); |
||||
|
cache.SetMaxAge(new TimeSpan(maxDays, 0, 0, 0)); |
||||
|
cache.SetRevalidation(HttpCacheRevalidation.AllCaches); |
||||
|
|
||||
|
string incomingEtag = context.Request.Headers["If-None-Match"]; |
||||
|
|
||||
|
cache.SetCacheability(HttpCacheability.Public); |
||||
|
|
||||
|
if (incomingEtag == null) |
||||
|
{ |
||||
|
return; |
||||
|
} |
||||
|
|
||||
|
response.Clear(); |
||||
|
response.StatusCode = (int)HttpStatusCode.NotModified; |
||||
|
response.SuppressContent = true; |
||||
|
} |
||||
|
#endregion
|
||||
|
} |
||||
|
} |
||||
Loading…
Reference in new issue