/// <summary> /// Loads the image to process. Always call this method first. /// </summary> /// <param name="stream"> /// The <see cref="T:System.IO.Stream"/> containing the image information. /// </param> /// <returns> /// The current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class. /// </returns> public ImageFactory Load(Stream stream) { ISupportedImageFormat format = FormatUtilities.GetFormat(stream); if (format == null) { throw new ImageFormatException("Input stream is not a supported format."); } MemoryStream memoryStream = new MemoryStream(); // Copy the stream. Disposal of the input stream is the responsibility // of the user. stream.CopyTo(memoryStream); // Set the position to 0 afterwards. if (stream.CanSeek) { stream.Position = 0; } memoryStream.Position = 0; // Set our image as the memory stream value. this.Image = format.Load(memoryStream); // Store the stream so we can dispose of it later. this.InputStream = memoryStream; // Set the other properties. format.Quality = DefaultQuality; format.IsIndexed = FormatUtilities.IsIndexed(this.Image); IQuantizableImageFormat imageFormat = format as IQuantizableImageFormat; if (imageFormat != null) { imageFormat.ColorCount = FormatUtilities.GetColorCount(this.Image); } this.backupFormat = format; this.CurrentImageFormat = format; // Always load the data. // TODO. Some custom data doesn't seem to get copied by default methods. foreach (int id in this.Image.PropertyIdList) { this.ExifPropertyItems[id] = this.Image.GetPropertyItem(id); } this.ShouldProcess = true; // Normalize the gamma component of the image. if (this.FixGamma) { this.Gamma(2.2F); } return(this); }
/// <summary> /// Loads the image to process. Always call this method first. /// </summary> /// <param name="imagePath">The absolute path to the image to load.</param> /// <returns> /// The current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class. /// </returns> public ImageFactory Load(string imagePath) { FileInfo fileInfo = new FileInfo(imagePath); if (fileInfo.Exists) { this.ImagePath = imagePath; // Open a file stream to prevent the need for lock. using (FileStream fileStream = new FileStream(imagePath, FileMode.Open, FileAccess.Read)) { ISupportedImageFormat format = FormatUtilities.GetFormat(fileStream); if (format == null) { throw new ImageFormatException("Input stream is not a supported format."); } MemoryStream memoryStream = new MemoryStream(); // Copy the stream. fileStream.CopyTo(memoryStream); // Set the position to 0 afterwards. fileStream.Position = memoryStream.Position = 0; // Set our image as the memory stream value. this.Image = format.Load(memoryStream); // Store the stream so we can dispose of it later. this.InputStream = memoryStream; // Set the other properties. format.Quality = DefaultQuality; format.IsIndexed = FormatUtilities.IsIndexed(this.Image); this.backupFormat = format; this.CurrentImageFormat = format; // Always load the data. foreach (PropertyItem propertyItem in this.Image.PropertyItems) { this.ExifPropertyItems[propertyItem.Id] = propertyItem; } this.ShouldProcess = true; } } else { throw new FileNotFoundException(imagePath); } return(this); }
/// <summary> /// Loads the image to process. Always call this method first. /// </summary> /// <param name="stream"> /// The <see cref="T:System.IO.Stream"/> containing the image information. /// </param> /// <returns> /// The current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class. /// </returns> public ImageFactory Load(Stream stream) { MemoryStream memoryStream = new MemoryStream(); // Copy the stream. Disposal of the input stream is the responsibility // of the user. stream.CopyTo(memoryStream); // Set the position to 0 afterwards. if (stream.CanSeek) { stream.Position = 0; } ISupportedImageFormat format = FormatUtilities.GetFormat(memoryStream); if (format == null) { throw new ImageFormatException("Input stream is not a supported format."); } // Set our image as the memory stream value. this.Image = format.Load(memoryStream); // Store the stream so we can dispose of it later. this.InputStream = memoryStream; // Set the other properties. format.Quality = DefaultQuality; format.IsIndexed = FormatUtilities.IsIndexed(this.Image); this.backupFormat = format; this.CurrentImageFormat = format; // Always load the data. // TODO. Some custom data doesn't seem to get copied by default methods. foreach (int id in this.Image.PropertyIdList) { this.ExifPropertyItems[id] = this.Image.GetPropertyItem(id); } this.backupExifPropertyItems = this.ExifPropertyItems; // Ensure the image is in the most efficient format. Image formatted = this.Image.Copy(); this.Image.Dispose(); this.Image = formatted; this.ShouldProcess = true; return(this); }
/// <summary> /// Get the correct mime-type for the given string input. /// </summary> /// <param name="path"> /// The path to the cached image. /// </param> /// <returns> /// The <see cref="string"/> matching the correct mime-type. /// </returns> public static string GetMimeType(string path) { using (FileStream file = new FileStream(path, FileMode.Open, FileAccess.Read, FileShare.Read, 4096, false)) { ISupportedImageFormat format = FormatUtilities.GetFormat(file); if (format != null) { return(format.MimeType); } } return(string.Empty); }
/// <summary> /// Loads the image to process from an array of bytes. Always call this method first. /// </summary> /// <param name="bytes"> /// The <see cref="T:System.Byte"/> containing the image information. /// </param> /// <returns> /// The current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class. /// </returns> public ImageFactory Load(byte[] bytes) { MemoryStream memoryStream = new MemoryStream(bytes); ISupportedImageFormat format = FormatUtilities.GetFormat(memoryStream); if (format == null) { throw new ImageFormatException("Input stream is not a supported format."); } // Set our image as the memory stream value. this.Image = format.Load(memoryStream); // Store the stream so we can dispose of it later. this.InputStream = memoryStream; // Set the other properties. format.Quality = DefaultQuality; format.IsIndexed = FormatUtilities.IsIndexed(this.Image); IQuantizableImageFormat imageFormat = format as IQuantizableImageFormat; if (imageFormat != null) { imageFormat.ColorCount = FormatUtilities.GetColorCount(this.Image); } this.backupFormat = format; this.CurrentImageFormat = format; // Always load the data. foreach (int id in this.Image.PropertyIdList) { this.ExifPropertyItems[id] = this.Image.GetPropertyItem(id); } this.ShouldProcess = true; // Normalize the gamma component of the image. if (this.FixGamma) { this.Gamma(2.2F); } return(this); }
/// <summary> /// Loads the image to process from an array of bytes. Always call this method first. /// </summary> /// <param name="bytes"> /// The <see cref="T:System.Byte"/> containing the image information. /// </param> /// <returns> /// The current instance of the <see cref="T:ImageProcessor.ImageFactory"/> class. /// </returns> public ImageFactory Load(byte[] bytes) { MemoryStream memoryStream = new MemoryStream(bytes); ISupportedImageFormat format = FormatUtilities.GetFormat(memoryStream); if (format == null) { throw new ImageFormatException("Input stream is not a supported format."); } // Set our image as the memory stream value. this.Image = format.Load(memoryStream); // Store the stream so we can dispose of it later. this.InputStream = memoryStream; // Set the other properties. format.Quality = DefaultQuality; format.IsIndexed = FormatUtilities.IsIndexed(this.Image); this.backupFormat = format; this.CurrentImageFormat = format; // Always load the data. foreach (int id in this.Image.PropertyIdList) { this.ExifPropertyItems[id] = this.Image.GetPropertyItem(id); } // Ensure the image is in the most efficient format. Image formatted = this.Image.Copy(); this.Image.Dispose(); this.Image = formatted; this.ShouldProcess = true; return(this); }
/// <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> /// <returns> /// The <see cref="T:System.Threading.Tasks.Task"/>. /// </returns> private async Task ProcessImageAsync(HttpContext context) { HttpRequest request = context.Request; string rawUrl = this.GetRequestUrl(request); // Should we ignore this request? if (string.IsNullOrWhiteSpace(rawUrl) || rawUrl.IndexOf("IPIGNORE=TRUE", StringComparison.InvariantCultureIgnoreCase) >= 0) { return; } // Sometimes the request is url encoded // See https://github.com/JimBobSquarePants/ImageProcessor/issues/478 // This causes a bit of a nightmare as the incoming request is corrupted and cannot be used for splitting // out each url part. This becomes a manual job. string url = rawUrl; string applicationPath = request.ApplicationPath; IImageService currentService = this.GetImageServiceForRequest(url, applicationPath); if (currentService == null) { return; } // Parse url UrlParser.ParseUrl(url, currentService.Prefix, out string requestPath, out string queryString); string originalQueryString = queryString; // Replace any presets in the querystring with the actual value. queryString = this.ReplacePresetsInQueryString(queryString); var httpContextBase = new HttpContextWrapper(context); // Execute the handler which can change the querystring var validatingArgs = new ValidatingRequestEventArgs(httpContextBase, queryString); this.OnValidatingRequest(validatingArgs); // If the validation has failed based on events, return if (validatingArgs.Cancel) { ImageProcessorBootstrapper.Instance.Logger.Log <ImageProcessingModule>($"Image processing for {url} has been cancelled by an event"); return; } // Re-assign based on event handlers queryString = validatingArgs.QueryString; if (string.IsNullOrWhiteSpace(originalQueryString) && !string.IsNullOrWhiteSpace(queryString)) { url = url + "?" + queryString; } else if (!string.IsNullOrWhiteSpace(queryString)) { url = Regex.Replace(url, originalQueryString, queryString, RegexOptions.IgnoreCase); } // Map the request path if file local. bool isFileLocal = currentService.IsFileLocalService; if (currentService.IsFileLocalService) { requestPath = HostingEnvironment.MapPath(requestPath); } if (string.IsNullOrWhiteSpace(requestPath)) { return; } // Parse any protocol values from settings if no protocol is present. if (currentService.Settings.ContainsKey("Protocol") && (ProtocolRegex.Matches(requestPath).Count == 0 || ProtocolRegex.Matches(requestPath)[0].Index > 0)) { // ReSharper disable once PossibleNullReferenceException requestPath = currentService.Settings["Protocol"] + "://" + requestPath.TrimStart('/'); } // Break out if we don't meet critera. // First check that the request path is valid and whether we are intercepting all requests or the querystring is valid. bool interceptAll = interceptAllRequests != null && interceptAllRequests.Value; if (string.IsNullOrWhiteSpace(requestPath) || (!interceptAll && string.IsNullOrWhiteSpace(queryString))) { return; } // Check whether the path is valid for other requests. // We've already checked the unprefixed requests in GetImageServiceForRequest(). if (!string.IsNullOrWhiteSpace(currentService.Prefix) && !currentService.IsValidRequest(requestPath)) { return; } bool isNewOrUpdated = false; string cachedPath = string.Empty; bool processing = false; IWebGraphicsProcessor[] processors = null; AnimationProcessMode mode = AnimationProcessMode.First; using (await Locker.ReaderLockAsync(rawUrl).ConfigureAwait(false)) { // Parse the url to see whether we should be doing any work. // If we're not intercepting all requests and we don't have valid instructions we shoul break here. if (!string.IsNullOrWhiteSpace(queryString)) { // Attempt to match querystring and processors. processors = ImageFactoryExtensions.GetMatchingProcessors(queryString); // Animation is not a processor but can be a specific request so we should allow it. mode = this.ParseAnimationMode(queryString, out bool processAnimation); // Are we processing or cache busting? processing = processors != null && (processors.Length > 0 || processAnimation); bool cacheBusting = ParseCacheBuster(queryString); if (!processing && !cacheBusting) { // No? Someone is either attacking the server or hasn't read the instructions. string message = $"The request {request.Unvalidated.RawUrl} could not be understood by the server due to malformed syntax."; ImageProcessorBootstrapper.Instance.Logger.Log <ImageProcessingModule>(message); return; } } // Create a new cache to help process and cache the request. this.imageCache = (IImageCache)ImageProcessorConfiguration.Instance .ImageCache.GetInstance(requestPath, url, queryString); // Is the file new or updated? isNewOrUpdated = await this.imageCache.IsNewOrUpdatedAsync().ConfigureAwait(false); cachedPath = this.imageCache.CachedPath; if (!isNewOrUpdated) { // The cached file is valid so just rewrite the path. this.imageCache.RewritePath(context); // Redirect if not a locally store file. if (!new Uri(cachedPath).IsFile) { context.ApplicationInstance.CompleteRequest(); } return; } } // Only process if the file has been updated. using (await Locker.WriterLockAsync(rawUrl).ConfigureAwait(false)) { // Ok let's get the image byte[] imageBuffer = null; string mimeType; try { if (currentService is IImageService2 imageService2) { imageBuffer = await imageService2.GetImage(requestPath, context).ConfigureAwait(false); } else { imageBuffer = await currentService.GetImage(requestPath).ConfigureAwait(false); } } catch (HttpException ex) { // We want 404's to be handled by IIS so that other handlers/modules can still run. if (ex.GetHttpCode() == (int)HttpStatusCode.NotFound) { ImageProcessorBootstrapper.Instance.Logger.Log <ImageProcessingModule>(ex.Message); return; } } if (imageBuffer == null) { return; } // Using recyclable streams here should dramatically reduce the overhead required using (MemoryStream inStream = MemoryStreamPool.Shared.GetStream("inStream", imageBuffer, 0, imageBuffer.Length)) { // Process the Image. Use a recyclable stream here to reduce the allocations MemoryStream outStream = MemoryStreamPool.Shared.GetStream(); if (!string.IsNullOrWhiteSpace(queryString)) { if (processing) { // Process the image. bool exif = preserveExifMetaData != null && preserveExifMetaData.Value; MetaDataMode metaMode = !exif ? MetaDataMode.None : metaDataMode.Value; bool gamma = fixGamma != null && fixGamma.Value; try { using (var imageFactory = new ImageFactory(metaMode, gamma) { AnimationProcessMode = mode }) { imageFactory.Load(inStream).AutoProcess(processors).Save(outStream); mimeType = imageFactory.CurrentImageFormat.MimeType; } } catch (ImageFormatException) { ImageProcessorBootstrapper.Instance.Logger.Log <ImageProcessingModule>($"Request {url} is not a valid image."); return; } } else { // We're cache-busting. Allow the value to be cached await inStream.CopyToAsync(outStream).ConfigureAwait(false); mimeType = FormatUtilities.GetFormat(outStream).MimeType; } } else { // We're capturing all requests. await inStream.CopyToAsync(outStream).ConfigureAwait(false); mimeType = FormatUtilities.GetFormat(outStream).MimeType; } // Fire the post processing event. EventHandler <PostProcessingEventArgs> handler = OnPostProcessing; if (handler != null) { string extension = Path.GetExtension(cachedPath); var args = new PostProcessingEventArgs { Context = context, ImageStream = outStream, ImageExtension = extension }; handler(this, args); outStream = args.ImageStream; } // Add to the cache. await this.imageCache.AddImageToCacheAsync(outStream, mimeType).ConfigureAwait(false); // Cleanup outStream.Dispose(); } // Store the response type and cache dependency in the context for later retrieval. context.Items[CachedResponseTypeKey] = mimeType; bool isFileCached = new Uri(cachedPath).IsFile; if (isFileLocal) { if (isFileCached) { // Some services might only provide filename so we can't monitor for the browser. context.Items[CachedResponseFileDependency] = Path.GetFileName(requestPath) == requestPath ? new[] { cachedPath } : new[] { requestPath, cachedPath }; } else { context.Items[CachedResponseFileDependency] = Path.GetFileName(requestPath) == requestPath ? null : new[] { requestPath }; } } else if (isFileCached) { context.Items[CachedResponseFileDependency] = new[] { cachedPath }; } // The cached file has been saved so now rewrite the path. this.imageCache.RewritePath(context); // Redirect if not a locally store file. if (!new Uri(cachedPath).IsFile) { context.ApplicationInstance.CompleteRequest(); } // Trim the cache. await this.imageCache.TrimCacheAsync().ConfigureAwait(false); } }
/// <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> /// <returns> /// The <see cref="T:System.Threading.Tasks.Task"/>. /// </returns> private async Task ProcessImageAsync(HttpContext context) { HttpRequest request = context.Request; // Should we ignore this request? if (request.Unvalidated.RawUrl.ToUpperInvariant().Contains("IPIGNORE=TRUE")) { return; } IImageService currentService = this.GetImageServiceForRequest(request); if (currentService != null) { bool isFileLocal = currentService.IsFileLocalService; string url = request.Url.ToString(); bool isLegacy = ProtocolRegex.Matches(url).Count > 1; bool hasMultiParams = url.Count(f => f == '?') > 1; string requestPath; string queryString = string.Empty; string urlParameters = string.Empty; // Legacy support. I'd like to remove this asap. if (isLegacy && hasMultiParams) { // We need to split the querystring to get the actual values we want. string[] paths = url.Split('?'); requestPath = paths[1]; // Handle extension-less urls. if (paths.Length > 3) { queryString = paths[3]; urlParameters = paths[2]; } else if (paths.Length > 1) { queryString = paths[2]; } } else { if (string.IsNullOrWhiteSpace(currentService.Prefix)) { requestPath = currentService.IsFileLocalService ? HostingEnvironment.MapPath(request.Path) : request.Path; queryString = request.QueryString.ToString(); } else { // Parse any protocol values from settings. string protocol = currentService.Settings.ContainsKey("Protocol") ? currentService.Settings["Protocol"] + "://" : currentService.GetType() == typeof(RemoteImageService) ? request.Url.Scheme + "://" : string.Empty; // Handle requests that require parameters. if (hasMultiParams) { string[] paths = url.Split('?'); requestPath = protocol + request.Path.TrimStart('/').Remove(0, currentService.Prefix.Length).TrimStart('/') + "?" + paths[1]; queryString = paths[2]; } else { requestPath = protocol + request.Path.TrimStart('/').Remove(0, currentService.Prefix.Length).TrimStart('/'); queryString = request.QueryString.ToString(); } } } // Replace any presets in the querystring with the actual value. queryString = this.ReplacePresetsInQueryString(queryString); // Execute the handler which can change the querystring queryString = this.CheckQuerystringHandler(context, queryString, request.Unvalidated.RawUrl); // Break out if we don't meet critera. bool interceptAll = interceptAllRequests != null && interceptAllRequests.Value; if (string.IsNullOrWhiteSpace(requestPath) || (!interceptAll && string.IsNullOrWhiteSpace(queryString))) { return; } string parts = !string.IsNullOrWhiteSpace(urlParameters) ? "?" + urlParameters : string.Empty; string fullPath = string.Format("{0}{1}?{2}", requestPath, parts, queryString); object resourcePath; // More legacy support code. if (hasMultiParams) { resourcePath = string.IsNullOrWhiteSpace(urlParameters) ? new Uri(requestPath, UriKind.RelativeOrAbsolute) : new Uri(requestPath + "?" + urlParameters, UriKind.RelativeOrAbsolute); } else { resourcePath = requestPath; } // Check whether the path is valid for other requests. if (!currentService.IsValidRequest(resourcePath.ToString())) { return; } string combined = requestPath + fullPath + queryString; using (await Locker.LockAsync(combined)) { // Create a new cache to help process and cache the request. this.imageCache = (IImageCache)ImageProcessorConfiguration.Instance .ImageCache.GetInstance(requestPath, fullPath, queryString); // Is the file new or updated? bool isNewOrUpdated = await this.imageCache.IsNewOrUpdatedAsync(); string cachedPath = this.imageCache.CachedPath; // Only process if the file has been updated. if (isNewOrUpdated) { // Process the image. bool exif = preserveExifMetaData != null && preserveExifMetaData.Value; bool gamma = fixGamma != null && fixGamma.Value; AnimationProcessMode mode = this.ParseAnimationMode(queryString); using (ImageFactory imageFactory = new ImageFactory(exif, gamma) { AnimationProcessMode = mode }) { byte[] imageBuffer = null; string mimeType; try { imageBuffer = await currentService.GetImage(resourcePath); } catch (HttpException ex) { // We want 404's to be handled by IIS so that other handlers/modules can still run. if (ex.GetHttpCode() == (int)HttpStatusCode.NotFound) { return; } } if (imageBuffer == null) { return; } using (MemoryStream inStream = new MemoryStream(imageBuffer)) { // Process the Image MemoryStream outStream = new MemoryStream(); if (!string.IsNullOrWhiteSpace(queryString)) { imageFactory.Load(inStream).AutoProcess(queryString).Save(outStream); mimeType = imageFactory.CurrentImageFormat.MimeType; } else { await inStream.CopyToAsync(outStream); mimeType = FormatUtilities.GetFormat(outStream).MimeType; } // Fire the post processing event. EventHandler <PostProcessingEventArgs> handler = OnPostProcessing; if (handler != null) { string extension = Path.GetExtension(cachedPath); PostProcessingEventArgs args = new PostProcessingEventArgs { Context = context, ImageStream = outStream, ImageExtension = extension }; handler(this, args); outStream = args.ImageStream; } // Add to the cache. await this.imageCache.AddImageToCacheAsync(outStream, mimeType); // Cleanup outStream.Dispose(); } // Store the response type and cache dependency in the context for later retrieval. context.Items[CachedResponseTypeKey] = mimeType; bool isFileCached = new Uri(cachedPath).IsFile; if (isFileLocal) { if (isFileCached) { // Some services might only provide filename so we can't monitor for the browser. context.Items[CachedResponseFileDependency] = Path.GetFileName(requestPath) == requestPath ? new List <string> { cachedPath } : new List <string> { requestPath, cachedPath }; } else { context.Items[CachedResponseFileDependency] = Path.GetFileName(requestPath) == requestPath ? null : new List <string> { requestPath }; } } else if (isFileCached) { context.Items[CachedResponseFileDependency] = new List <string> { cachedPath }; } } } // The cached file is valid so just rewrite the path. this.imageCache.RewritePath(context); // Redirect if not a locally store file. if (!new Uri(cachedPath).IsFile) { context.ApplicationInstance.CompleteRequest(); } } } }
/// <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> /// <returns> /// The <see cref="T:System.Threading.Tasks.Task"/>. /// </returns> private async Task ProcessImageAsync(HttpContext context) { HttpRequest request = context.Request; string rawUrl = request.Unvalidated.RawUrl; // Should we ignore this request? if (string.IsNullOrWhiteSpace(rawUrl) || rawUrl.ToUpperInvariant().Contains("IPIGNORE=TRUE")) { return; } // Sometimes the request is url encoded so we have to decode. // See https://github.com/JimBobSquarePants/ImageProcessor/issues/478 // This causes a bit of a nightmare as the incoming request is corrupted and cannot be used for splitting // out each url part. This becomes a manual job. string url = this.DecodeUrlString(rawUrl); string applicationPath = request.ApplicationPath; IImageService currentService = this.GetImageServiceForRequest(url, applicationPath); if (currentService != null) { // Remove any service identifier prefixes from the url. string prefix = currentService.Prefix; if (!string.IsNullOrWhiteSpace(prefix)) { url = url.Split(new[] { prefix }, StringSplitOptions.None)[1].TrimStart("?"); } // Identify each part of the incoming request. int queryCount = url.Count(f => f == '?'); bool hasParams = queryCount > 0; bool hasMultiParams = queryCount > 1; string[] splitPath = url.Split('?'); // Ensure we include any relevent querystring parameters into our request path for third party requests. string requestPath = hasMultiParams ? string.Join("?", splitPath.Take(splitPath.Length - 1)) : splitPath[0]; string queryString = hasParams ? splitPath[splitPath.Length - 1] : string.Empty; // Map the request path if file local. bool isFileLocal = currentService.IsFileLocalService; if (currentService.IsFileLocalService) { requestPath = HostingEnvironment.MapPath(requestPath); } // Parse any protocol values from settings if no protocol is present. if (currentService.Settings.ContainsKey("Protocol") && (ProtocolRegex.Matches(url).Count == 0 || ProtocolRegex.Matches(url)[0].Index > 0)) { // ReSharper disable once PossibleNullReferenceException requestPath = currentService.Settings["Protocol"] + "://" + requestPath.TrimStart('/'); } // Replace any presets in the querystring with the actual value. queryString = this.ReplacePresetsInQueryString(queryString); HttpContextWrapper httpContextBase = new HttpContextWrapper(context); // Execute the handler which can change the querystring // LEGACY: #pragma warning disable 618 queryString = this.CheckQuerystringHandler(context, queryString, rawUrl); #pragma warning restore 618 // NEW WAY: ValidatingRequestEventArgs validatingArgs = new ValidatingRequestEventArgs(httpContextBase, queryString); this.OnValidatingRequest(validatingArgs); // If the validation has failed based on events, return if (validatingArgs.Cancel) { ImageProcessorBootstrapper.Instance.Logger.Log <ImageProcessingModule>("Image processing has been cancelled by an event"); return; } // Re-assign based on event handlers queryString = validatingArgs.QueryString; // Break out if we don't meet critera. bool interceptAll = interceptAllRequests != null && interceptAllRequests.Value; if (string.IsNullOrWhiteSpace(requestPath) || (!interceptAll && string.IsNullOrWhiteSpace(queryString))) { return; } // Check whether the path is valid for other requests. // We've already checked the unprefixed requests in GetImageServiceForRequest(). if (!string.IsNullOrWhiteSpace(prefix) && !currentService.IsValidRequest(requestPath)) { return; } using (await Locker.LockAsync(rawUrl)) { // Create a new cache to help process and cache the request. this.imageCache = (IImageCache)ImageProcessorConfiguration.Instance .ImageCache.GetInstance(requestPath, url, queryString); // Is the file new or updated? bool isNewOrUpdated = await this.imageCache.IsNewOrUpdatedAsync(); string cachedPath = this.imageCache.CachedPath; // Only process if the file has been updated. if (isNewOrUpdated) { byte[] imageBuffer = null; string mimeType; try { imageBuffer = await currentService.GetImage(requestPath); } catch (HttpException ex) { // We want 404's to be handled by IIS so that other handlers/modules can still run. if (ex.GetHttpCode() == (int)HttpStatusCode.NotFound) { ImageProcessorBootstrapper.Instance.Logger.Log <ImageProcessingModule>(ex.Message); return; } } if (imageBuffer == null) { return; } using (MemoryStream inStream = new MemoryStream(imageBuffer)) { // Process the Image MemoryStream outStream = new MemoryStream(); if (!string.IsNullOrWhiteSpace(queryString)) { // Animation is not a processor but can be a specific request so we should allow it. bool processAnimation; AnimationProcessMode mode = this.ParseAnimationMode(queryString, out processAnimation); // Attempt to match querystring and processors. IWebGraphicsProcessor[] processors = ImageFactoryExtensions.GetMatchingProcessors(queryString); if (processors.Any() || processAnimation) { // Process the image. bool exif = preserveExifMetaData != null && preserveExifMetaData.Value; bool gamma = fixGamma != null && fixGamma.Value; using (ImageFactory imageFactory = new ImageFactory(exif, gamma) { AnimationProcessMode = mode }) { imageFactory.Load(inStream).AutoProcess(processors).Save(outStream); mimeType = imageFactory.CurrentImageFormat.MimeType; } } else if (this.ParseCacheBuster(queryString)) { // We're cachebustng. Allow the value to be cached await inStream.CopyToAsync(outStream); mimeType = FormatUtilities.GetFormat(outStream).MimeType; } else { // No match? Someone is either attacking the server or hasn't read the instructions. // Either way throw an exception to prevent caching. string message = $"The request {request.Unvalidated.RawUrl} could not be understood by the server due to malformed syntax."; ImageProcessorBootstrapper.Instance.Logger.Log <ImageProcessingModule>(message); throw new HttpException((int)HttpStatusCode.BadRequest, message); } } else { // We're capturing all requests. await inStream.CopyToAsync(outStream); mimeType = FormatUtilities.GetFormat(outStream).MimeType; } // Fire the post processing event. EventHandler <PostProcessingEventArgs> handler = OnPostProcessing; if (handler != null) { string extension = Path.GetExtension(cachedPath); PostProcessingEventArgs args = new PostProcessingEventArgs { Context = context, ImageStream = outStream, ImageExtension = extension }; handler(this, args); outStream = args.ImageStream; } // Add to the cache. await this.imageCache.AddImageToCacheAsync(outStream, mimeType); // Cleanup outStream.Dispose(); } // Store the response type and cache dependency in the context for later retrieval. context.Items[CachedResponseTypeKey] = mimeType; bool isFileCached = new Uri(cachedPath).IsFile; if (isFileLocal) { if (isFileCached) { // Some services might only provide filename so we can't monitor for the browser. context.Items[CachedResponseFileDependency] = Path.GetFileName(requestPath) == requestPath ? new[] { cachedPath } : new[] { requestPath, cachedPath }; } else { context.Items[CachedResponseFileDependency] = Path.GetFileName(requestPath) == requestPath ? null : new[] { requestPath }; } } else if (isFileCached) { context.Items[CachedResponseFileDependency] = new[] { cachedPath }; } } // The cached file is valid so just rewrite the path. this.imageCache.RewritePath(context); // Redirect if not a locally store file. if (!new Uri(cachedPath).IsFile) { context.ApplicationInstance.CompleteRequest(); } } } }