DefaultHttpHandler.cs source code in C# .NET

Source code for the .NET framework in C#

                        
Code:

                         / DotNET / DotNET / 8.0 / untmp / whidbey / REDBITS / ndp / fx / src / xsp / System / Web / DefaultHttpHandler.cs / 1 / DefaultHttpHandler.cs
                        

                        
                            //------------------------------------------------------------------------------ 
// 
//     Copyright (c) Microsoft Corporation.  All rights reserved.
// 
//----------------------------------------------------------------------------- 

namespace System.Web { 
 
    using System;
    using System.Collections; 
    using System.Collections.Specialized;
    using System.Globalization;
    using System.Text;
    using System.Web.Util; 
    using System.Security.Permissions;
 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public class DefaultHttpHandler : IHttpAsyncHandler { 

        private HttpContext _context;
        private NameValueCollection _executeUrlHeaders;
 
        public DefaultHttpHandler() {
        } 
 
        protected HttpContext Context {
            get { return _context; } 
        }

        // headers to provide to execute url
        protected NameValueCollection ExecuteUrlHeaders { 
            get {
                if (_executeUrlHeaders == null && _context != null) { 
                    _executeUrlHeaders = new NameValueCollection(_context.Request.Headers); 
                }
 
                return _executeUrlHeaders;
            }
        }
 
        // called when we know a precondition for calling
        // execute URL has been violated 
        public virtual void OnExecuteUrlPreconditionFailure() { 
            // do nothing - the derived class might throw
        } 

        // add a virtual method that provides the request target for the EXECUTE_URL call
        // if return null, the default calls EXECUTE_URL for the default target
        public virtual String OverrideExecuteUrlPath() { 
            return null;
        } 
 
        internal static bool IsClassicAspRequest(String filePath) {
            return StringUtil.StringEndsWithIgnoreCase(filePath, ".asp"); 
        }

        public virtual IAsyncResult BeginProcessRequest(HttpContext context, AsyncCallback callback, Object state) {
            _context = context; 
            HttpResponse response = _context.Response;
 
            if (response.CanExecuteUrlForEntireResponse) { 
                // use ExecuteUrl
                String path = OverrideExecuteUrlPath(); 

                if (path != null && !HttpRuntime.IsFullTrust) {
                    // validate that an untrusted derived classes (not in GAC)
                    // didn't set the path to a place that CAS wouldn't let it access 
                    if (!this.GetType().Assembly.GlobalAssemblyCache) {
                        HttpRuntime.CheckFilePermission(context.Request.MapPath(path)); 
                    } 
                }
 
                return response.BeginExecuteUrlForEntireResponse(path, _executeUrlHeaders, callback, state);
            }
            else {
                // let the base class throw if it doesn't want static files handler 
                OnExecuteUrlPreconditionFailure();
 
                // use static file handler 
                _context = null; // don't keep request data alive in sync case
 
                HttpRequest request = context.Request;

                // refuse POST requests
                if (request.HttpVerb == HttpVerb.POST) { 
                    throw new HttpException(405, SR.GetString(SR.Method_not_allowed, request.HttpMethod, request.Path));
                } 
 
                // refuse .asp requests
                if (IsClassicAspRequest(request.FilePath)) { 
                    throw new HttpException(403, SR.GetString(SR.Path_forbidden, request.Path));
                }

                // default to static file handler 
                StaticFileHandler.ProcessRequestInternal(context);
 
                // return async result indicating completion 
                return new HttpAsyncResult(callback, state, true, null, null);
            } 
        }

        public virtual void EndProcessRequest(IAsyncResult result) {
            if (_context != null) { 
                HttpResponse response = _context.Response;
                _context = null; 
                response.EndExecuteUrlForEntireResponse(result); 
            }
        } 

        public virtual void ProcessRequest(HttpContext context) {
            // this handler should never be called synchronously
            throw new InvalidOperationException(SR.GetString(SR.Cannot_call_defaulthttphandler_sync)); 
        }
 
        public virtual bool IsReusable { 
            get { return false; }
        } 
    }
}

Link Menu

Network programming in C#, Network Programming in VB.NET, Network Programming in .NET
This book is available now!
Buy at Amazon US or
Buy at Amazon UK