/* stolen from the 1.0 S.W.Config ModulesConfiguration.cs */ internal HttpModuleCollection LoadModules(HttpApplication app) { HttpModuleCollection coll = new HttpModuleCollection(); Type type; foreach (HttpModuleAction item in Modules) { type = HttpApplication.LoadType(item.Type); if (type == null) { /* XXX should we throw here? */ continue; } IHttpModule module = (IHttpModule)Activator.CreateInstance(type, BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance, null, null, null); module.Init(app); coll.AddModule(item.Name, module); } /* XXX the 1.x config stuff does this * indirectly.. I'm not sure we want to do it * here, but this keeps things working in much * the same fashion in 2.0-land. */ { IHttpModule module = new DefaultAuthenticationModule(); module.Init(app); coll.AddModule("DefaultAuthentication", module); } return(coll); }
public ImpersonationServiceInitializer(ILogProvider logProvider) { var log = logProvider.GetLogger(GetType().Name); log.Trace(() => "ImpersonationServiceInitializer instantianted. Creating single ImpersonationTicketExpirationModule instance."); _impersonationTickedExpirationModule = new ImpersonationTicketExpirationModule(logProvider); }
public override void Init() { base.Init(); foreach (string moduleName in this.Modules) { string appName = "MYAPP"; IHttpModule module = this.Modules[moduleName]; SessionStateModule ssm = module as SessionStateModule; if (ssm != null) { FieldInfo storeInfo = typeof(SessionStateModule).GetField("_store", BindingFlags.Instance | BindingFlags.NonPublic); SessionStateStoreProviderBase store = (SessionStateStoreProviderBase)storeInfo.GetValue(ssm); if (store == null)//In IIS7 Integrated mode, module.Init() is called later { FieldInfo runtimeInfo = typeof(HttpRuntime).GetField("_theRuntime", BindingFlags.Static | BindingFlags.NonPublic); HttpRuntime theRuntime = (HttpRuntime)runtimeInfo.GetValue(null); FieldInfo appNameInfo = typeof(HttpRuntime).GetField("_appDomainAppId", BindingFlags.Instance | BindingFlags.NonPublic); appNameInfo.SetValue(theRuntime, appName); } else { Type storeType = store.GetType(); if (storeType.Name.Equals("OutOfProcSessionStateStore")) { FieldInfo uribaseInfo = storeType.GetField("s_uribase", BindingFlags.Static | BindingFlags.NonPublic); uribaseInfo.SetValue(storeType, appName); } } } } }
internal void AddModule(String name, IHttpModule m) { _all = null; _allKeys = null; BaseAdd(name, m); }
void Pipeline_PostAuthorizeRequestStart(IHttpModule sender, HttpContext context) { if (IsRemotePath(c.Pipeline.PreRewritePath)) { c.Pipeline.SkipFileTypeCheck = true; } }
static void Pipeline_Rewrite(IHttpModule sender, HttpContext context, IUrlEventArgs e) { if (e.VirtualPath.StartsWith(PathUtils.ResolveAppRelative("~/photos/"), StringComparison.OrdinalIgnoreCase)) { e.VirtualPath = PathUtils.ResolveAppRelative("~/App_Data/") + e.VirtualPath.Substring(PathUtils.AppVirtualPath.Length).TrimStart('/'); } }
private static void CleanupHttpSession(System.Web.HttpApplication context) { // Get a reference to the session module IHttpModule module = context.Modules["Session"]; if (module != null && module.GetType() == typeof(SessionStateModule)) { SessionStateModule stateModule = (SessionStateModule)module; stateModule.Start += (sender, args) => { // Ensure that expired NHibernate sessions are disposed SessionManager.Instance.GetSession(SessionManager.Instance.DefaultSessionKey); SessionEndModule.SessionObjectKey = SessionManager.SessionKeyIdentifier; EventHandler <SessionEndedEventArgs> sessionEndHandler = null; sessionEndHandler = (s, a) => { SessionManager.Instance.DisposeSession((Guid)(a.SessionObject)); SessionEndModule.SessionEnd -= sessionEndHandler; }; SessionEndModule.SessionEnd += sessionEndHandler; }; } }
public void Init(HttpApplication context) { var allKeys = context.Modules.AllKeys; var key = allKeys.FirstOrDefault(x => x.Contains("InfoModule")); IHttpModule module = context.Modules[key]; if (module != null && module is InfoModule) { InfoModule timerModule = (InfoModule)module; timerModule.RequestTimed += (src, arg) => { totalTime += arg.Duration; requestCount++; }; } context.EndRequest += (src, arg) => { var cached = context.Context.Cache.Get("Day"); if (cached != null && (bool)cached == false) { context.Context.Response.Write(CreateSummary()); } context.Context.Cache["day"] = false; }; }
/// <summary> /// Configures the <see paramref="app"/> instance and its modules. /// </summary> /// <remarks> /// When called, configures <see paramref="app"/> using the <see cref="IApplicationContext"/> instance /// provided in <paramref name="appContext"/> and the templates available in /// <see cref="ApplicationTemplate"/> and <see cref="ModuleTemplates"/>. /// </remarks> /// <param name="appContext">the application context instance to be used for resolving object references.</param> /// <param name="app">the <see cref="HttpApplication"/> instance to be configured.</param> public static void Configure(IConfigurableApplicationContext appContext, HttpApplication app) { IObjectDefinition applicationDefinition = s_applicationDefinition; if (s_applicationDefinition != null) { appContext.ObjectFactory.ConfigureObject(app, "ApplicationTemplate", applicationDefinition); } lock (s_moduleDefinitions.SyncRoot) { HttpModuleCollection modules = app.Modules; foreach (DictionaryEntry moduleEntry in s_moduleDefinitions) { string moduleName = (string)moduleEntry.Key; IObjectDefinition od = s_moduleDefinitions[moduleName]; IHttpModule module = modules[moduleName]; if (module != null) { appContext.ObjectFactory.ConfigureObject(module, moduleName, od); } else { throw ConfigurationUtils.CreateConfigurationException(string.Format("failed applying module template '{0}' - no matching module found", moduleName)); } } } }
static void Pipeline_AuthorizeImage(IHttpModule sender, HttpContext context, IUrlAuthorizationEventArgs e) { if (e.VirtualPath.StartsWith(PathUtils.ResolveAppRelative("~/App_Data/photos/"), StringComparison.OrdinalIgnoreCase)) { e.AllowAccess = true; } }
public virtual void InitHandler(HttpApplication context, IHttpModule module = null) { Guard.CheckArgumentNull(context); VirtualPath = HostingEnvironment.ApplicationVirtualPath; if (VirtualPath == null) { return; // Test unit } SiteAlias = HostingEnvironment.SiteName.Replace(" ", ""); PhysicalPath = HostingEnvironment.ApplicationPhysicalPath; // The first System.Exception for the current HTTP request/response process; Exception appError = HttpContext.Current == null ? null : HttpContext.Current.Error; if (appError != null && CustomError != null) { CustomError(appError); } if (module != null) // && !isModuleInit) { context.PostAuthenticateRequest += new EventHandler(OnPostAuthenticate); // pipeline error NullReferenceException PipelineModuleStepContainer.GetStepArray } }
private void HandleHttpModule(IHttpModule module, IHttpRequest req, IHttpResponse resp) { var frontend = new FrontendHandler(req, resp); var handleCtx = new SimpleHttpRequestContext(); handleCtx.Request = req; handleCtx.Response = resp; var result = module.HandleRequest(handleCtx); if (result.Errors.Count > 0) { throw new AggregateException(result.Errors); } var directOutput = resp.DirectOutput; if (!directOutput) { var header = ServiceLocator.Current.GetInstance <IHtmlTemplate>("__header"); frontend.WriteVars(header); resp.Prefix(header.Render()); } if (!directOutput) { var footer = ServiceLocator.Current.GetInstance <IHtmlTemplate>("__footer"); frontend.WriteVars(footer); resp.Append(footer.Render()); } }
/// <summary> /// Adds a route to this configuration /// </summary> /// <returns>The server configuration.</returns> /// <param name="route">The expression used to pre-filter requests before invoking the handler.</param> /// <param name="handler">The handler module that will execute the operation.</param> public ServerConfig AddRoute(string route, IHttpModule handler) { if (handler == null) { throw new ArgumentNullException(nameof(handler)); } Router rt; if (this.Router == null) { this.Router = rt = new Router(); } else if (this.Router is Router) { rt = this.Router as Router; } else { throw new Exception($"Cannot use the AddRoute method unless the {nameof(Router)} is an instance of {typeof(Router).FullName}"); } rt.Add(route, handler); return(this); }
public void FirePreHandleImageAsync(IHttpModule sender, HttpContext context, IAsyncResponsePlan e) { System.Threading.Interlocked.Increment(ref processedCount); if (PreHandleImageAsync != null) { PreHandleImageAsync(sender, context, e); } }
void Pipeline_Rewrite(IHttpModule sender, HttpContext context, ImageResizer.Configuration.IUrlEventArgs e) { if (e.QueryString["scache"] == null) e.QueryString["scache"] = "disk"; if (e.VirtualPath.StartsWith("/rw/", StringComparison.OrdinalIgnoreCase)) e.VirtualPath = "/s3/resizer-web" + e.VirtualPath.Substring(3); if (e.VirtualPath.StartsWith("/ri/", StringComparison.OrdinalIgnoreCase)) e.VirtualPath = "/s3/resizer-images" + e.VirtualPath.Substring(3); if (e.VirtualPath.StartsWith("/un/", StringComparison.OrdinalIgnoreCase)) e.VirtualPath = "/remote/images.unsplash.com" + e.VirtualPath.Substring(3); }
void Pipeline_Rewrite(IHttpModule sender, HttpContext context, Configuration.IUrlEventArgs e) { //Remove 'iefix' immediately if it's not relevant so we don't slow down static requests or do needless re-encoding. if (!NeedsPngFix(context)) { e.QueryString.Remove("iefix"); } }
/// <summary> /// Adds a route to this configuration /// </summary> /// <returns>The server configuration.</returns> /// <param name="handler">The handler function that will execute the operation.</param> public ServerConfig AddRoute(IHttpModule handler) { if (handler == null) { throw new ArgumentNullException(nameof(handler)); } return(AddRoute(null, handler)); }
public MockHttpApplication(IHttpModule module) { if (module != null) { module.Init(this); } this.module = module; }
public void Init(HttpApplication context) { this.currentModule = ObjectService.GetObject <HttpModuleWrapperInternal>(); if (this.currentModule != null) { this.currentModule.Init(context); } }
public void Dispose() { if (this.currentModule != null) { this.currentModule.Dispose(); this.currentModule = null; } }
void Pipeline_PostRewrite(IHttpModule sender, HttpContext context, IUrlEventArgs e) { // Server-side cachebreaker if (e.QueryString["red_dot"] != "true" && ShouldWatermark()) { e.QueryString["red_dot"] = "true"; } }
public MockHttpApplication(IHttpModule module, bool passNullAsSender) { if (module != null) { module.Init(this); } this.module = module; this.passNullAsSender = passNullAsSender; }
private void Pipeline_Rewrite(IHttpModule sender, HttpContext context, IUrlEventArgs e) { if (e.VirtualPath == null) { context.RewritePath("index.html"); } string fileCache = ImageHelper.checkFile(e.VirtualPath); context.RewritePath(fileCache); //string root = ConfigurationManager.AppSettings["ImageRoot"] ?? String.Empty; //root = "~/upload/"; //var test = VirtualPathUtility.ToAbsolute(root); //if (e.VirtualPath.StartsWith(VirtualPathUtility.ToAbsolute(root), StringComparison.OrdinalIgnoreCase)) //{ // e.VirtualPath = Regex.Replace(e.VirtualPath, // string.Format("/{root}/img/([0-9]+)\\.([0-9]+)-([^/]+)\\.(jpg|jpeg|png|gif)"), // delegate(Match match) // { // e.QueryString["width"] = match.Groups[1].Value; // e.QueryString["height"] = match.Groups[2].Value; // e.QueryString["mode"] = "scale"; // return string.Format("/{root}/img/{match.Groups[3].Value}.{match.Groups[4].Value}"); // }); // //e.VirtualPath = Regex.Replace(e.VirtualPath, string.Format("/{root}/img/([0-9]+)w-([^/]+)\\.(jpg|jpeg|png|gif)"), // // delegate(Match match) // // { // // e.QueryString["width"] = match.Groups[1].Value; // // e.QueryString["mode"] = "scale"; // // return string.Format("/{root}/img/{match.Groups[2].Value}.{match.Groups[3].Value}"); // // }); // //e.VirtualPath = Regex.Replace(e.VirtualPath, string.Format("/{root}/img/([0-9]+)h-([^/]+)\\.(jpg|jpeg|png|gif)"), // // delegate(Match match) // // { // // e.QueryString["height"] = match.Groups[1].Value; // // e.QueryString["mode"] = "scale"; // // return string.Format("/{root}/img/{match.Groups[2].Value}.{match.Groups[3].Value}"); // // }); // context.RewritePath(e.VirtualPath); //} //else { // //using V308CMS.Static.Helpers; // string fileCache = ImageHelper.checkFile(e.VirtualPath); // context.RewritePath(fileCache); // //var fInfo = new System.IO.FileInfo(e.VirtualPath); // //var result = fInfo.DirectoryName; //} }
public void Init(HttpApplication context) { IHttpModule module = _module.Value; if (module != null) { module.Init(context); } }
public void Dispose() { IHttpModule module = _module.Value; if (module != null) { module.Dispose(); } }
void Pipeline_RewriteDefaults(IHttpModule sender, HttpContext context, Configuration.IUrlEventArgs e) { //If this is IE 6 or earlier, and catchall is enabled, add iefix=true to all requests, regardless of (current) file type. //Rewriting rules may change the format or add it later, we'll filter to just PNG requests in PostRewrite. if (NeedsPngFix(context) && CatchAll) { e.QueryString["iefix"] = "true"; //If CatchAll is enabled, it's a png, and we set the default value here. } }
public void Init(HttpApplication context) { IHttpModule httpModule = context.Modules.Get("Session"); var sessionModule = httpModule as SessionStateModule; if (sessionModule != null) { sessionModule.Start += OnSessionStart; } }
protected virtual void PostAuthorizeRequestStarted(IHttpModule httpModule, HttpContext httpContext) { var path = HttpUtility.UrlDecode(httpContext.Request.Url.AbsolutePath); if (path == null || !this._isEditModeImageUrlRegex.IsMatch(path)) { return; } Config.Current.Pipeline.PreRewritePath = this._isEditModeImageUrlRegex.Match(path).Groups[1].Value; }
void Pipeline_PreHandleImage(IHttpModule sender, HttpContext context, ImageResizer.Caching.IResponseArgs e) { if (!ImageResizer.ExtensionMethods.NameValueCollectionExtensions.Get<bool>(e.RewrittenQuerystring, "showbytes", false)) return; var old = e.ResizeImageToStream; ((ResponseArgs)e).ResizeImageToStream = delegate(Stream s) { MemoryStream ms = new MemoryStream(8096); old(ms); WriteTextInPng(ms.Length.ToString("N") + " bytes", s); }; }
void IHttpModule.Init(HttpApplication appContext) { IHttpModule module = appContext.Modules["Timer"]; if (module is TimerModule timerModule) { timerModule.RequestTimed += HandleRequestTimed; } appContext.EndRequest += HandleEndRequest; }
public void ShouldStartModules() { var applicationModules = new IHttpModule[] { new ModularityApplicationObserver(), }; _observer.InitializeModules(applicationModules); _moduleMock.Verify(m => m.Initialize()); }
private void OnRewriteDefaults(IHttpModule sender, HttpContext context, IUrlEventArgs e) { var preset = e.QueryString["preset"]; if (!string.IsNullOrWhiteSpace(preset) && !_presetNames.Contains(preset.ToLowerInvariant())) { throw new HttpException(404, "Not Found"); } ServiceLocator.Current.GetInstance <IContentHashHelper>().RedirectIfWrongHash(new HttpContextWrapper(context), ServiceLocator.Current.GetInstance <IContentRouteHelper>().Content); }
protected virtual void PostAuthorizeRequestStarted(IHttpModule httpModule, HttpContext httpContext) { var path = httpContext.Request.Url.AbsolutePath; var split = isEditModeImageUrlRegex.Split(path); if (split.Length == 3) // 3 because when a match occurs it does so at the start and end of the input { Config.Current.Pipeline.PreRewritePath = split[1]; } }
public static bool RegisterInPartialTrust(HttpApplication application, IHttpModule module) { if (application == null) throw new ArgumentNullException("application"); if (module == null) throw new ArgumentNullException("module"); if (IsHighlyTrusted()) return false; lock (_lock) { // // On-demand allocate a map of modules per application. // if (_moduleListByApp == null) _moduleListByApp = new Dictionary<HttpApplication, IList<IHttpModule>>(); // // Get the list of modules for the application. If this is // the first registration for the supplied application object // then setup a new and empty list. // var moduleList = _moduleListByApp.Find(application); if (moduleList == null) { moduleList = new List<IHttpModule>(); _moduleListByApp.Add(application, moduleList); } else if (moduleList.Contains(module)) throw new ApplicationException("Duplicate module registration."); // // Add the module to list of registered modules for the // given application object. // moduleList.Add(module); } // // Setup a closure to automatically unregister the module // when the application fires its Disposed event. // var housekeeper = new Housekeeper(module); application.Disposed += housekeeper.OnApplicationDisposed; return true; }
private void OnPostAuthorizeRequestStart(IHttpModule sender, HttpContext context) { // A hack to get ImageResizer working with images in edit mode. // In edit mode image URLs look like http://host.com/ui/CMS/Content/contentassets/0c51b2fa1f464956aab221c6ecc21804/file.jpg,,82777?epieditmode=False&width=100 // For some reason, URLs that have commas in them aren't processed by ImageResizer, so they need to be removed from the end of the path. // Episerver can still route content even without the commas and the content ID. // Thumbnail URLs should not be modified, e.g. // http://host.com/ui/CMS/Content/contentassets/0c51b2fa1f464956aab221c6ecc21804/file.jpg,,82777/Thumbnail?epieditmode=False?1470652477313 var fixedUrl = PathRegex.Replace(context.Request.Url.AbsolutePath, string.Empty); Config.Current.Pipeline.PreRewritePath = fixedUrl; }
private void OnPostAuthorizeRequestStart(IHttpModule sender, HttpContext context) { if (context.Request.Url.ToString().Contains("Thumbnail?epieditmode")) return; var absolutePath = CleanEditModePath(context.Request.Url.AbsolutePath); var resolvedContent = __urlResolver.Route(new UrlBuilder(absolutePath)); if (resolvedContent == null) { return; } var isMediaContent = resolvedContent is MediaData; if (!isMediaContent) { return; } var previewOrEditMode = RequestSegmentContext.CurrentContextMode == ContextMode.Edit || RequestSegmentContext.CurrentContextMode == ContextMode.Preview; // Disable cache if editing or previewing if (!previewOrEditMode) { return; } Config.Current.Pipeline.PreRewritePath = absolutePath; var modifiedQueryString = new NameValueCollection(Config.Current.Pipeline.ModifiedQueryString) { { "process", ProcessWhen.Always.ToString() }, { "cache", ServerCacheMode.No.ToString() } }; Config.Current.Pipeline.ModifiedQueryString = modifiedQueryString; }
/// <summary> /// Add a HTTP module /// </summary> /// <param name="module">Module to include</param> /// <remarks>Modules are executed in the order they are added.</remarks> public void Add(IHttpModule module) { if (module == null) throw new ArgumentNullException("module"); var worker = module as IWorkerModule; if (worker != null) _workerModules.Add(worker); var auth = module as IAuthenticationModule; if (auth != null) _authenticationModules.Add(auth); var auth2 = module as IAuthorizationModule; if (auth2 != null) _authorizationModules.Add(auth2); var routing = module as IRoutingModule; if (routing != null) _routingModules.Add(routing); _modules.Add(module); }
private void Pipeline_PostRewrite(IHttpModule sender, HttpContext context, IUrlEventArgs e) { HttpRequest httpRequest = HttpContext.Current.Request; // If resolution of current screen has been passed, set maxwidth // parameter for ImageResizer to handle in its pipeline HttpCookie httpCookie = httpRequest.Cookies.Get(ResolutionCookieKey); if (httpCookie != null) { e.QueryString.Add("maxwidth", httpCookie.Value); } // A cookie has not been set. If current user agent is identified // as a mobile device, serve the smallest image else if (httpRequest.UserAgent.ToLower().Contains(UserAgentMobileSubstring)) { string width = _resolutions[_resolutions.Length - 1]; e.QueryString.Add("maxwidth", width); } }
private void OnPostAuthorizeRequestStart(IHttpModule sender, HttpContext context) { if (context.Request.Url.ToString().Contains("Thumbnail?epieditmode")) return; string absolutePath = this.CleanEditModePath(context.Request.Url.AbsolutePath); IContent resolvedContent = __urlResolver.Route(new UrlBuilder(absolutePath)); if (resolvedContent == null) { return; } bool isMediaContent = resolvedContent is MediaData; if (!isMediaContent) { return; } Config.Current.Pipeline.SkipFileTypeCheck = true; bool previewOrEditMode = ( RequestSegmentContext.CurrentContextMode == ContextMode.Edit || RequestSegmentContext.CurrentContextMode == ContextMode.Preview ); // Disable cache if editing or previewing if (previewOrEditMode) { Config.Current.Pipeline.PreRewritePath = absolutePath; NameValueCollection modifiedQueryString = new NameValueCollection(Config.Current.Pipeline.ModifiedQueryString); modifiedQueryString.Add("process", ProcessWhen.Always.ToString()); modifiedQueryString.Add("cache", ServerCacheMode.No.ToString()); Config.Current.Pipeline.ModifiedQueryString = modifiedQueryString; } }
public static ICollection GetModules(HttpApplication application) { if (application == null) throw new ArgumentNullException("application"); try { IHttpModule[] modules = new IHttpModule[application.Modules.Count]; application.Modules.CopyTo(modules, 0); return modules; } catch (SecurityException) { // // Pass through because probably this is a partially trusted // environment that does not have access to the modules // collection over HttpApplication so we have to resort // to our own devices... // } lock (_lock) { if (_moduleListByApp == null) return new IHttpModule[0]; IList moduleList = (IList) _moduleListByApp[application]; if (moduleList == null) return new IHttpModule[0]; IHttpModule[] modules = new IHttpModule[moduleList.Count]; moduleList.CopyTo(modules, 0); return modules; } }
static void Pipeline_Rewrite(IHttpModule sender, HttpContext context, IUrlEventArgs e) { if (e.VirtualPath.StartsWith(PathUtils.ResolveAppRelative("~/photos/"), StringComparison.OrdinalIgnoreCase)) e.VirtualPath = PathUtils.ResolveAppRelative("~/App_Data/") + e.VirtualPath.Substring(PathUtils.AppVirtualPath.Length).TrimStart('/'); }
static void Pipeline_AuthorizeImage(IHttpModule sender, HttpContext context, IUrlAuthorizationEventArgs e) { if (e.VirtualPath.StartsWith(PathUtils.ResolveAppRelative("~/App_Data/photos/"), StringComparison.OrdinalIgnoreCase)) e.AllowAccess = true; }
private static bool UnregisterInPartialTrust(HttpApplication application, IHttpModule module) { Debug.Assert(application != null); Debug.Assert(module != null); if (module == null) throw new ArgumentNullException("module"); if (IsHighlyTrusted()) return false; lock (_lock) { // // Get the module list for the given application object. // if (_moduleListByApp == null) return false; var moduleList = _moduleListByApp.Find(application); if (moduleList == null) return false; // // Remove the module from the list if it's in there. // var index = moduleList.IndexOf(module); if (index < 0) return false; moduleList.RemoveAt(index); // // If the list is empty then remove the application entry. // If this results in the entire map becoming empty then // release it. // if (moduleList.Count == 0) { _moduleListByApp.Remove(application); if (_moduleListByApp.Count == 0) _moduleListByApp = null; } } return true; }
/*<resizer> * <watermarks> * <otherimages path="~/watermarks" align="topleft" width="50%" /> * <group name="wmark"> * <image path="~/watermarks/image.png" align="topleft" width="50px" height="50px" /> * </group> */ //top, left, bottom, right = px or percentages (relative to container) //relativeTo = image|imageArea|padding|border|margin|canvas //drawAs overlay|background //image //imagesettings //align = topleft|topright|bottomleft|bottomright|... void Pipeline_PostRewrite(IHttpModule sender, HttpContext context, IUrlEventArgs e) { //Cache breaking string[] parts = WatermarksToUse(e.QueryString); if (parts == null) return; foreach (string w in parts) { if (NamedWatermarks.ContainsKey(w)) { IEnumerable<Layer> layers = NamedWatermarks[w]; foreach (Layer l in layers) { e.QueryString["watermark-cachebreak"] = (e.QueryString["watermark-cachebreak"] ?? "") + "_" + l.GetDataHash().ToString(); } } } }
public Housekeeper(IHttpModule module) { _module = module; }
void Pipeline_PostAuthorizeRequestStart(IHttpModule sender, HttpContext context) { if (IsRemotePath(c.Pipeline.PreRewritePath)) c.Pipeline.SkipFileTypeCheck = true; }
/*<resizer> * <watermarks> * <otherimages path="~/watermarks" align="topleft" width="50%" /> * <group name="wmark"> * <image path="~/watermarks/image.png" align="topleft" width="50px" height="50px" /> * </group> */ //top, left, bottom, right = px or percentages (relative to container) //relativeTo = image|imageArea|padding|border|margin|canvas //drawAs overlay|background //image //imagesettings //align = topleft|topright|bottomleft|bottomright|... void Pipeline_PostRewrite(IHttpModule sender, HttpContext context, IUrlEventArgs e) { //Cache breaking string watermark = e.QueryString["watermark"]; //from the querystring if (string.IsNullOrEmpty(watermark)) return; string[] parts = watermark.Split(new string[] { "," }, StringSplitOptions.RemoveEmptyEntries); foreach (string w in parts) { if (NamedWatermarks.ContainsKey(w)) { IEnumerable<Layer> layers = NamedWatermarks[w]; foreach (Layer l in layers) { e.QueryString["watermark-cachebreak"] = (e.QueryString["watermark-cachebreak"] ?? "") + "_" + l.GetDataHash().ToString(); } } } }
private static void Init(HttpApplication mvcApplication, IHttpModule module) { module.Init(mvcApplication); }
internal void AddModule(string key, IHttpModule m) { _Modules = null; _Keys = null; BaseAdd(key, m); }
internal void AddModule (string key, IHttpModule m) { BaseAdd (key, m); }
/// <summary> /// Add a HTTP module /// </summary> /// <param name="module">Module to include</param> /// <remarks>Modules are executed in the order they are added.</remarks> public void Add(IHttpModule module) { _moduleManager.Add(module); }
public static IEnumerable<IHttpModule> GetModules(HttpApplication application) { if (application == null) throw new ArgumentNullException("application"); try { var modules = new IHttpModule[application.Modules.Count]; application.Modules.CopyTo(modules, 0); return modules; } catch (SecurityException) { // // Pass through because probably this is a partially trusted // environment that does not have access to the modules // collection over HttpApplication so we have to resort // to our own devices... // } lock (registryLock) { if (moduleListByApp == null) return Enumerable.Empty<IHttpModule>(); var moduleList = moduleListByApp.Find(application); if (moduleList == null) return Enumerable.Empty<IHttpModule>(); var modules = new IHttpModule[moduleList.Count]; moduleList.CopyTo(modules, 0); return modules; } }
/// <summary> /// In case there is no querystring attached to the file (thus no operations on the fly) we can /// redirect directly to the blob. This let us take advantage of the CDN (if configured). /// </summary> /// <param name="sender"></param> /// <param name="context"></param> /// <param name="e"></param> void Pipeline_PostRewrite(IHttpModule sender, HttpContext context, Configuration.IUrlEventArgs e) { string prefix = vpp.VirtualFilesystemPrefix; // Check if prefix is within virtual file system and if there is no querystring if (e.VirtualPath.StartsWith(prefix, StringComparison.OrdinalIgnoreCase) && e.QueryString.Count == 0) { // Strip prefix from virtual path; keep container and blob string relativeBlobURL = e.VirtualPath.Substring(vPath.Length -1).Trim('/', '\\'); // Redirect to blob context.Response.Redirect(blobStorageEndpoint + relativeBlobURL); } }
public ModuleEntry(string name, IHttpModule module) { Name = name; Module = module; }
public void AddModuleToCollection(HttpModuleCollection target, string name, IHttpModule m) { CommonReflectionUtil.MakeDelegate<Action<string, IHttpModule>>(target, this._mi_HttpModuleCollection_AddModule)(name, m); }
void Pipeline_AuthorizeImage(IHttpModule sender, HttpContext context, IUrlAuthorizationEventArgs e) { //Don't allow direct access to the cache. if (e.VirtualPath.StartsWith(this.VirtualCacheDir, StringComparison.OrdinalIgnoreCase)) e.AllowAccess = false; }