WorkerRequest.cs source code in C# .NET

Source code for the .NET framework in C#

                        

Code:

/ FXUpdate3074 / FXUpdate3074 / 1.1 / untmp / whidbey / QFE / ndp / fx / src / xsp / System / Web / WorkerRequest.cs / 9 / WorkerRequest.cs

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

/*++ 
 
   Copyright    (c)    1999    Microsoft Corporation
 
   Module  Name :

        HttpWorkerRequest.cs
 
   Abstract:
 
        This module defines the base worker class used by ASP.NET Managed 
        code for request processing.
 
--*/

namespace System.Web {
    using System.Text; 

    using System.Collections; 
    using System.Collections.Specialized; 
    using System.Globalization;
    using System.Runtime.InteropServices; 
    using System.Web.Configuration;
    using System.Web.Hosting;
    using System.Web.Management; // for webevent tracing
    using System.Web.Util; 
    using System.Security.Permissions;
 
    // 
    // ***************************************************************************
    // 


    /// 
    ///    This abstract class defines the base worker methods and enumerations used by ASP.NET managed code for request processing. 
    /// 
    [ComVisible(false)] 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)] 
    [AspNetHostingPermission(SecurityAction.InheritanceDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public abstract class HttpWorkerRequest { 
        private DateTime _startTime;
        //it is up to the derived classes to implement a real id
        #pragma warning disable 0649
        private Guid _traceId; 
        #pragma warning restore 0649
 
 
        protected HttpWorkerRequest()
        { 
            _startTime = DateTime.UtcNow;
        }

        // *********************************************************************** 

        // 
        // Indexed Headers. All headers that are defined by HTTP/1.1. These 
        // values are used as offsets into arrays and as token values.
        // 
        // IMPORTANT : Notice request + response values overlap. Make sure you
        // know which type of header array you are indexing.
        //
 
        //
        // general-headers [section 4.5] 
        // 

 
        /// 
        ///    [To be supplied.]
        /// 
        public const int HeaderCacheControl          = 0; 

        ///  
        ///    [To be supplied.] 
        /// 
        public const int HeaderConnection            = 1; 

        /// 
        ///    [To be supplied.]
        ///  
        public const int HeaderDate                  = 2;
 
        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderKeepAlive             = 3;   // not in rfc

        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderPragma                = 4; 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderTrailer               = 5;

        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderTransferEncoding      = 6; 

        ///  
        ///    [To be supplied.]
        /// 
        public const int HeaderUpgrade               = 7;
 
        /// 
        ///    [To be supplied.] 
        ///  
        public const int HeaderVia                   = 8;
 
        /// 
        ///    [To be supplied.]
        /// 
        public const int HeaderWarning               = 9; 

        // 
        // entity-headers  [section 7.1] 
        //
 

        /// 
        ///    [To be supplied.]
        ///  
        public const int HeaderAllow                 = 10;
 
        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderContentLength         = 11;

        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderContentType           = 12; 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderContentEncoding       = 13;

        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderContentLanguage       = 14; 

        ///  
        ///    [To be supplied.]
        /// 
        public const int HeaderContentLocation       = 15;
 
        /// 
        ///    [To be supplied.] 
        ///  
        public const int HeaderContentMd5            = 16;
 
        /// 
        ///    [To be supplied.]
        /// 
        public const int HeaderContentRange          = 17; 

        ///  
        ///    [To be supplied.] 
        /// 
        public const int HeaderExpires               = 18; 

        /// 
        ///    [To be supplied.]
        ///  
        public const int HeaderLastModified          = 19;
 
        // 
        // request-headers [section 5.3]
        // 


        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderAccept                = 20; 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderAcceptCharset         = 21;

        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderAcceptEncoding        = 22; 

        ///  
        ///    [To be supplied.]
        /// 
        public const int HeaderAcceptLanguage        = 23;
 
        /// 
        ///    [To be supplied.] 
        ///  
        public const int HeaderAuthorization         = 24;
 
        /// 
        ///    [To be supplied.]
        /// 
        public const int HeaderCookie                = 25;   // not in rfc 

        ///  
        ///    [To be supplied.] 
        /// 
        public const int HeaderExpect                = 26; 

        /// 
        ///    [To be supplied.]
        ///  
        public const int HeaderFrom                  = 27;
 
        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderHost                  = 28;

        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderIfMatch               = 29; 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderIfModifiedSince       = 30;

        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderIfNoneMatch           = 31; 

        ///  
        ///    [To be supplied.]
        /// 
        public const int HeaderIfRange               = 32;
 
        /// 
        ///    [To be supplied.] 
        ///  
        public const int HeaderIfUnmodifiedSince     = 33;
 
        /// 
        ///    [To be supplied.]
        /// 
        public const int HeaderMaxForwards           = 34; 

        ///  
        ///    [To be supplied.] 
        /// 
        public const int HeaderProxyAuthorization    = 35; 

        /// 
        ///    [To be supplied.]
        ///  
        public const int HeaderReferer               = 36;
 
        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderRange                 = 37;

        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderTe                    = 38; 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderUserAgent             = 39;

        // 
        // Request headers end here
        // 
 

        ///  
        ///    [To be supplied.]
        /// 
        public const int RequestHeaderMaximum        = 40;
 
        //
        // response-headers [section 6.2] 
        // 

 
        /// 
        ///    [To be supplied.]
        /// 
        public const int HeaderAcceptRanges          = 20; 

        ///  
        ///    [To be supplied.] 
        /// 
        public const int HeaderAge                   = 21; 

        /// 
        ///    [To be supplied.]
        ///  
        public const int HeaderEtag                  = 22;
 
        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderLocation              = 23;

        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderProxyAuthenticate     = 24; 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public const int HeaderRetryAfter            = 25;

        ///  
        ///    [To be supplied.]
        ///  
        public const int HeaderServer                = 26; 

        ///  
        ///    [To be supplied.]
        /// 
        public const int HeaderSetCookie             = 27;   // not in rfc
 
        /// 
        ///    [To be supplied.] 
        ///  
        public const int HeaderVary                  = 28;
 
        /// 
        ///    [To be supplied.]
        /// 
        public const int HeaderWwwAuthenticate       = 29; 

        // 
        // Response headers end here 
        //
 

        /// 
        ///    [To be supplied.]
        ///  
        public const int ResponseHeaderMaximum       = 30;
 
        // ************************************************************************ 

        // 
        // Request reasons
        //

 
        /// 
        ///    [To be supplied.] 
        ///  
        /// 
        public const int ReasonResponseCacheMiss     = 0; 

        /// 
        ///    [To be supplied.]
        ///  
        /// 
        public const int ReasonFileHandleCacheMiss   = 1; 
 
        /// 
        ///    [To be supplied.] 
        /// 
        /// 
        public const int ReasonCachePolicy           = 2;
 
        /// 
        ///    [To be supplied.] 
        ///  
        /// 
        public const int ReasonCacheSecurity         = 3; 

        /// 
        ///    [To be supplied.]
        ///  
        /// 
        public const int ReasonClientDisconnect      = 4; 
 

        ///  
        ///    [To be supplied.]
        /// 
        /// 
        public const int ReasonDefault               = ReasonResponseCacheMiss; 

 
        // *********************************************************************** 

        // 
        // Access to request related members
        //

        // required members 

 
        ///  
        ///     Returns the virtual path to the requested Uri, including PathInfo.
        ///  
        public abstract String  GetUriPath();           // "/foo/page.aspx/tail"

        /// 
        ///    Provides Access to the specified member of the request header. 
        /// 
        public abstract String  GetQueryString();       // "param=bar" 
 
        /// 
        ///    Gets the URI requsted by the client, which will include PathInfo and QueryString if it exists. 
        ///    This value is unaffected by any URL rewriting or routing that may occur on the server.
        /// 
        public abstract String  GetRawUrl();            // "/foo/page.aspx/tail?param=bar"
 
        /// 
        ///    Provides Access to the specified member of the request header. 
        ///  
        public abstract String  GetHttpVerbName();      // "GET"
 
        /// 
        ///    Provides Access to the specified member of the request header.
        /// 
        public abstract String  GetHttpVersion();       // "HTTP/1.1" 

 
        ///  
        ///    Provides Access to the specified member of the request header.
        ///  
        public abstract String  GetRemoteAddress();     // client's ip address

        /// 
        ///    Provides Access to the specified member of the request header. 
        /// 
        public abstract int     GetRemotePort();        // client's port 
 
        /// 
        ///    Provides Access to the specified member of the request header. 
        /// 
        public abstract String  GetLocalAddress();      // server's ip address

        ///  
        ///    Provides Access to the specified member of the request header.
        ///  
        public abstract int     GetLocalPort();         // server's port 

        internal virtual String GetLocalPortAsString() { 
            return GetLocalPort().ToString(NumberFormatInfo.InvariantInfo);
        }

        // optional members with defaults supplied 

        internal virtual bool IsRewriteModuleEnabled { 
            get { 
                return false;
            } 
        }

        /// 
        ///    When overriden in a derived class, returns the response query string as an array of bytes. 
        /// 
        public virtual byte[] GetQueryStringRawBytes() { 
            // access to raw qs for i18n 
            return null;
        } 


        /// 
        ///    When overriden in a derived class, returns the client computer's name. 
        /// 
        public virtual String GetRemoteName() { 
            // client's name 
            return GetRemoteAddress();
        } 


        /// 
        ///    When overriden in a derived class, returns the name of the local server. 
        /// 
        public virtual String GetServerName() { 
            // server's name 
            return GetLocalAddress();
        } 


        /// 
        ///    When overriden in a derived class, returns the ID of the current connection. 
        /// 
        ///  
        public virtual long GetConnectionID() { 
            // connection id
            return 0; 
        }


        ///  
        ///    When overriden in a derived class, returns the context ID of the current connection.
        ///  
        ///  
        public virtual long GetUrlContextID() {
            // UL APPID 
            return 0;
        }

 
        /// 
        ///    When overriden in a derived class, returns the application pool ID for the current URL. 
        ///  
        /// 
        public virtual String GetAppPoolID() { 
            // UL Application pool id
            return null;
        }
 

        ///  
        ///    When overriden in a derived class, returns the reason for the request. 
        /// 
        ///  
        public virtual int GetRequestReason() {
            // constants Reason... above
            return ReasonDefault;
        } 

 
        ///  
        ///    When overriden in a derived class, returns the client's impersonation token.
        ///  
        public virtual IntPtr GetUserToken() {
            // impersonation token
            return IntPtr.Zero;
        } 

 
        ///  
        public virtual IntPtr GetVirtualPathToken() {
            // impersonation token 
            return IntPtr.Zero;
        }

 
        /// 
        ///    When overriden in a derived class, returns a value indicating whether the connection is secure (using SSL). 
        ///  
        public virtual bool IsSecure() {
            // is over ssl? 
            return false;
        }

        ///  
        ///    When overriden in a derived class, returns the HTTP protocol (HTTP or HTTPS).
        ///  
        public virtual String GetProtocol() { 
            return IsSecure() ?  "https" : "http";
        } 

        /// 
        ///    When overriden in a derived class, returns the virtual path to the requested Uri, without PathInfo.
        ///  
        public virtual String GetFilePath() {
            // "/foo/page.aspx" 
            return GetUriPath(); 
        }
 
        internal VirtualPath GetFilePathObject() {
            // Don't allow malformed paths for security reasons
            return VirtualPath.Create(GetFilePath(), VirtualPathOptions.AllowAbsolutePath |
                VirtualPathOptions.AllowNull); 
        }
 
        ///  
        ///    When overriden in a derived class, returns the translated file path to the requested Uri (from virtual path to
        ///       UNC path, ie "/foo/page.aspx" to "c:\dir\page.aspx")  
        /// 
        public virtual String GetFilePathTranslated() {
            // "c:\dir\page.aspx"
            return null; 
        }
 
 
        /// 
        ///    When overriden in a derived class, returns additional 
        ///       path information for a resource with a URL extension. i.e. for the URL
        ///       /virdir/page.html/tail, the PathInfo value is /tail. 
        /// 
        public virtual String GetPathInfo() { 
            // "/tail"
            return String.Empty; 
        } 

 
        /// 
        ///    When overriden in a derived class, returns the virtual path to the
        ///       currently executing server application.
        ///  
        public virtual String GetAppPath() {
            // "/foo" 
            return null; 
        }
 

        /// 
        ///    When overriden in a derived class, returns the UNC-translated path to
        ///       the currently executing server application. 
        /// 
        public virtual String GetAppPathTranslated() { 
            // "c:\dir" 
            return null;
        } 

        //
        // Virtual methods to read the incoming request
        // 

        public virtual int GetPreloadedEntityBodyLength() { 
            byte[] bytes = GetPreloadedEntityBody(); 
            return (bytes != null) ? bytes.Length : 0;
        } 

        public virtual int GetPreloadedEntityBody(byte[] buffer, int offset) {
            int l = 0;
            byte[] bytes = GetPreloadedEntityBody(); 

            if (bytes != null) { 
                l = bytes.Length; 
                Buffer.BlockCopy(bytes, 0, buffer, offset, l);
            } 

            return l;
        }
 
        public virtual byte[] GetPreloadedEntityBody() {
            return null; 
        } 

        public virtual bool IsEntireEntityBodyIsPreloaded() { 
            return false;
        }

        public virtual int GetTotalEntityBodyLength() { 
            int l = 0;
 
            String contentLength = GetKnownRequestHeader(HeaderContentLength); 

            if (contentLength != null) { 
                try {
                    l = Int32.Parse(contentLength, CultureInfo.InvariantCulture);
                }
                catch { 
                }
            } 
 
            return l;
        } 

        public virtual int ReadEntityBody(byte[] buffer, int size) {
            return 0;
        } 

        public virtual int ReadEntityBody(byte[] buffer, int offset, int size) { 
            byte[] temp = new byte[size]; 
            int l = ReadEntityBody(temp, size);
 
            if (l > 0) {
                Buffer.BlockCopy(temp, 0, buffer, offset, l);
            }
 
            return l;
        } 
 

        ///  
        ///    [To be supplied.]
        /// 
        public virtual String GetKnownRequestHeader(int index) {
            return null; 
        }
 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public virtual String GetUnknownRequestHeader(String name) {
            return null;
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        [CLSCompliant(false)]
        public virtual String[][] GetUnknownRequestHeaders() {
            return null;
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        public virtual String GetServerVariable(String name) {
            return null;
        }
 

        ///  
        ///    [To be supplied.] 
        /// 
        ///  
        public virtual long GetBytesRead() {
            return 0;
        }
 

        ///  
        ///    [To be supplied.] 
        /// 
        ///  
        internal virtual DateTime GetStartTime() {
            return _startTime;
        }
 

        ///  
        ///    [To be supplied.] 
        /// 
        ///  
        internal virtual void ResetStartTime() {
            _startTime = DateTime.UtcNow;
        }
 

        ///  
        ///    [To be supplied.] 
        /// 
        public virtual String MapPath(String virtualPath) { 
            return null;
        }

 
        /// 
        ///    [To be supplied.] 
        ///  
        public virtual String MachineConfigPath {
            get { 
                return null;
            }
        }
 

        ///  
        ///    [To be supplied.] 
        /// 
        public virtual String RootWebConfigPath { 
            get {
                return null;
            }
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        public virtual String MachineInstallDirectory {
            get {
                return null;
            } 
        }
 
        // IntegratedTraceType in EtwTrace.cs 
        internal virtual void RaiseTraceEvent(IntegratedTraceType traceType, string eventData) {
            // do nothing 
        }

        internal virtual void RaiseTraceEvent(WebBaseEvent webEvent) {
            // do nothing 
        }
 
        ///  
        ///    [To be supplied.]
        ///  
        public virtual Guid RequestTraceIdentifier {
            get {
                return _traceId;
            } 
        }
 
        // 
        // Abstract methods to write the response
        // 


        /// 
        ///    [To be supplied.] 
        /// 
        public abstract void SendStatus(int statusCode, String statusDescription); 
 
        // for IIS 7, use both the status and substatus
        // this cannot be abstract 
        internal virtual void SendStatus(int statusCode, int subStatusCode, String statusDescription) {
            SendStatus(statusCode, statusDescription);
        }
 
        /// 
        ///    [To be supplied.] 
        ///  
        public abstract void SendKnownResponseHeader(int index, String value);
 

        /// 
        ///    [To be supplied.]
        ///  
        public abstract void SendUnknownResponseHeader(String name, String value);
 
        // headers encoding controled via HttpResponse.HeaderEncoding 
        internal virtual void SetHeaderEncoding(Encoding encoding) {
        } 


        /// 
        ///    [To be supplied.] 
        /// 
        public abstract void SendResponseFromMemory(byte[] data, int length); 
 

        ///  
        ///    [To be supplied.]
        /// 
        public virtual void SendResponseFromMemory(IntPtr data, int length) {
            if (length > 0) { 
                InternalSecurityPermissions.UnmanagedCode.Demand();
                // derived classes could have an efficient implementation 
                byte[] bytes = new byte[length]; 
                Misc.CopyMemory(data, 0, bytes, 0, length);
                SendResponseFromMemory(bytes, length); 
            }
        }

        internal virtual void SendResponseFromMemory(IntPtr data, int length, bool isBufferFromUnmanagedPool) { 
            // default implementation
            SendResponseFromMemory(data, length); 
        } 

 
        /// 
        ///    [To be supplied.]
        /// 
        public abstract void SendResponseFromFile(String filename, long offset, long length); 

 
        ///  
        ///    [To be supplied.]
        ///  
        public abstract void SendResponseFromFile(IntPtr handle, long offset, long length);

        internal virtual void TransmitFile(String filename, long length, bool isImpersonating) {
            TransmitFile(filename, 0, length, isImpersonating); 
        }
 
        internal virtual void TransmitFile(String filename, long offset, long length, bool isImpersonating) { 
            // default implementation
            SendResponseFromFile(filename, offset, length); 
        }

        //
        internal virtual bool SupportsLongTransmitFile { 
            get { return false; }
        } 
 
        // WOS 1555777: kernel cache support
        // If the worker request can kernel cache the response, it returns the 
        // kernel cache key; otherwise null.  The kernel cache key is used to invalidate
        // the entry if a dependency changes or the item is flushed from the managed
        // cache for any reason.
        internal virtual string SetupKernelCaching(int secondsToLive, string originalCacheUrl, bool enableKernelCacheForVaryByStar) { 
            return null;
        } 
 
        // WOS 1555777: kernel cache support
        internal virtual void DisableKernelCache() { 
            return;
        }

        internal virtual bool TrySkipIisCustomErrors { 
            get { return false; }
            set { } 
        } 

        // Execute Url 

        internal virtual bool SupportsExecuteUrl {
            get { return false; }
        } 

        internal virtual IAsyncResult BeginExecuteUrl( 
                                            String url, String method, String headers, 
                                            bool sendHeaders,
                                            bool addUserIndo, IntPtr token, String name, String authType, 
                                            byte[] entity,
                                            AsyncCallback cb, Object state) {
            throw new NotSupportedException(SR.GetString(SR.ExecuteUrl_not_supported));
        } 

        internal virtual void EndExecuteUrl(IAsyncResult result) { 
        } 

        internal virtual void UpdateResponseCounters(bool finalFlush, int bytesOut) { 
        }

        internal virtual void UpdateRequestCounters(int bytesIn) {
        } 

        ///  
        ///    [To be supplied.] 
        /// 
        public abstract void FlushResponse(bool finalFlush); 


        /// 
        ///    [To be supplied.] 
        /// 
        public abstract void EndOfRequest(); 
 
        //
        // Virtual helper methods 
        //


        ///  
        ///    [To be supplied.]
        ///  
        public delegate void EndOfSendNotification(HttpWorkerRequest wr, Object extraData); 

 
        /// 
        ///    [To be supplied.]
        /// 
        public virtual void SetEndOfSendNotification(EndOfSendNotification callback, Object extraData) { 
            // firing the callback helps with buffer recycling
        } 
 

        ///  
        ///    [To be supplied.]
        /// 
        public virtual void SendCalculatedContentLength(int contentLength) {
            // oportunity to add Content-Length header if not added by user 
        }
 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public virtual void SendCalculatedContentLength(long contentLength) {
            // default implementation is to call the int32 version
            SendCalculatedContentLength(Convert.ToInt32(contentLength)); 
        }
 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public virtual bool HeadersSent() {
            return true;
        } 

 
        ///  
        ///    [To be supplied.]
        ///  
        public virtual bool IsClientConnected() {
            return true;
        }
 

        ///  
        ///    [To be supplied.] 
        /// 
        public virtual void CloseConnection() { 
        }


        ///  
        ///    Defines the base worker class used by ASP.NET Managed code for request
        ///       processing. 
        ///  
        /// 
        public virtual byte [] GetClientCertificate() { 
            return new byte[0];
        }

 
        /// 
        ///    [To be supplied.] 
        ///  
        /// 
        public virtual DateTime GetClientCertificateValidFrom() { 
            return DateTime.Now;
        }

 
        /// 
        ///    [To be supplied.] 
        ///  
        /// 
        public virtual DateTime GetClientCertificateValidUntil() { 
            return DateTime.Now;
        }

 
        /// 
        ///    [To be supplied.] 
        ///  
        /// 
        public virtual byte [] GetClientCertificateBinaryIssuer() { 
            return new byte[0];
        }

        ///  
        ///    [To be supplied.]
        ///  
        ///  
        public virtual int GetClientCertificateEncoding() {
            return 0; 
        }

        /// 
        ///    [To be supplied.] 
        /// 
        ///  
        public virtual byte[] GetClientCertificatePublicKey() { 
            return new byte[0];
        } 

        // ************************************************************************

        // 
        // criteria to find out if there is posted data
        // 
 

        ///  
        ///    [To be supplied.]
        /// 
        public bool HasEntityBody() {
            // 
            // content length != 0 -> assume has content
            // 
 
            String contentLength = GetKnownRequestHeader(HeaderContentLength);
            if (contentLength != null && !contentLength.Equals("0")) 
                return true;

            //
            // any content encoding -> assume has content 
            //
 
            if (GetKnownRequestHeader(HeaderTransferEncoding) != null) 
                return true;
 
            //
            // preloaded -> has it
            //
 
            if (GetPreloadedEntityBody() != null)
                return true; 
 
            //
            // no posted data but everything preloaded -> no content 
            //

            if (IsEntireEntityBodyIsPreloaded())
                return false; 

            return false; 
        } 

        // ************************************************************************ 

        //
        // Default values for Http status description strings
        // 

 
        ///  
        ///    [To be supplied.]
        ///  
        public static String GetStatusDescription(int code) {
            if (code >= 100 && code < 600) {
                int i = code / 100;
                int j = code % 100; 

                if (j < s_HTTPStatusDescriptions[i].Length) 
                    return s_HTTPStatusDescriptions[i][j]; 
            }
 
            return String.Empty;
        }

        // Tables of status strings (first index is code/100, 2nd code%100) 

        private static readonly String[][] s_HTTPStatusDescriptions = new String[][] 
        { 
            null,
 
            new String[]
            {
                /* 100 */"Continue",
                /* 101 */ "Sswitching Protocols", 
                /* 102 */ "Processing"
            }, 
 
            new String[]
            { 
                /* 200 */"OK",
                /* 201 */ "Created",
                /* 202 */ "Accepted",
                /* 203 */ "Non-Authoritative Information", 
                /* 204 */ "No Content",
                /* 205 */ "Reset Content", 
                /* 206 */ "Partial Content", 
                /* 207 */ "Multi-Status"
            }, 

            new String[]
            {
                /* 300 */"Multiple Choices", 
                /* 301 */ "Moved Permanently",
                /* 302 */ "Found", 
                /* 303 */ "See Other", 
                /* 304 */ "Not Modified",
                /* 305 */ "Use Proxy", 
                /* 306 */ String.Empty,
                /* 307 */ "Temporary Redirect"
            },
 
            new String[]
            { 
                /* 400 */"Bad Request", 
                /* 401 */ "Unauthorized",
                /* 402 */ "Payment Required", 
                /* 403 */ "Forbidden",
                /* 404 */ "Not Found",
                /* 405 */ "Method Not Allowed",
                /* 406 */ "Not Acceptable", 
                /* 407 */ "Proxy Authentication Required",
                /* 408 */ "Request Timeout", 
                /* 409 */ "Conflict", 
                /* 410 */ "Gone",
                /* 411 */ "Length Required", 
                /* 412 */ "Precondition Failed",
                /* 413 */ "Request Entity Too Large",
                /* 414 */ "Request-Uri Too Long",
                /* 415 */ "Unsupported Media Type", 
                /* 416 */ "Requested Range Not Satisfiable",
                /* 417 */ "Expectation Failed", 
                /* 418 */ String.Empty, 
                /* 419 */ String.Empty,
                /* 420 */ String.Empty, 
                /* 421 */ String.Empty,
                /* 422 */ "Unprocessable Entity",
                /* 423 */ "Locked",
                /* 424 */ "Failed Dependency" 
            },
 
            new String[] 
            {
                /* 500 */"Internal Server Error", 
                /* 501 */ "Not Implemented",
                /* 502 */ "Bad Gateway",
                /* 503 */ "Service Unavailable",
                /* 504 */ "Gateway Timeout", 
                /* 505 */ "Http Version Not Supported",
                /* 506 */ String.Empty, 
                /* 507 */ "Insufficient Storage" 
            }
        }; 

        // ***********************************************************************

        // 
        // Header index to string conversions
        // 
 

        ///  
        ///    [To be supplied.]
        /// 
        public static int GetKnownRequestHeaderIndex(String header) {
            Object intObj = s_requestHeadersLoookupTable[header]; 

            if (intObj != null) 
                return(Int32)intObj; 
            else
                return -1; 
        }

        // ************************************************************************
 

        ///  
        ///    [To be supplied.] 
        /// 
        public static String GetKnownRequestHeaderName(int index) { 
            return s_requestHeaderNames[index];
        }

        internal static String GetServerVariableNameFromKnownRequestHeaderIndex(int index) { 
            return s_serverVarFromRequestHeaderNames[index];
        } 
 
        // ***********************************************************************
 

        /// 
        ///    [To be supplied.]
        ///  
        public static int GetKnownResponseHeaderIndex(String header) {
            Object intObj = s_responseHeadersLoookupTable[header]; 
 
            if (intObj != null)
                return(Int32)intObj; 
            else
                return -1;
        }
 
        // ***********************************************************************
 
 
        /// 
        ///    [To be supplied.] 
        /// 
        public static String GetKnownResponseHeaderName(int index) {
            return s_responseHeaderNames[index];
        } 

        // *********************************************************************** 
 

        // 
        // Implemenation -- lookup tables for header names
        //

        static private String[] s_serverVarFromRequestHeaderNames = new String[RequestHeaderMaximum]; 
        static private String[] s_requestHeaderNames  = new String[RequestHeaderMaximum];
        static private String[] s_responseHeaderNames = new String[ResponseHeaderMaximum]; 
        static private Hashtable s_requestHeadersLoookupTable  = new Hashtable(StringComparer.OrdinalIgnoreCase); 
        static private Hashtable s_responseHeadersLoookupTable = new Hashtable(StringComparer.OrdinalIgnoreCase);
 
        // ************************************************************************

        static private void DefineHeader(bool isRequest,
                                         bool isResponse, 
                                         int index,
                                         String headerName, 
                                         String serverVarName) { 

            Debug.Assert(serverVarName == null || serverVarName == "HTTP_" + headerName.ToUpper(CultureInfo.InvariantCulture).Replace('-', '_')); 

            Int32  i32 = new Int32();
            if (isRequest) {
                i32 = index; 
                s_serverVarFromRequestHeaderNames[index] = serverVarName;
                s_requestHeaderNames[index] = headerName; 
                s_requestHeadersLoookupTable.Add(headerName, i32); 
            }
 
            if (isResponse) {
                i32 = index;
                s_responseHeaderNames[index] = headerName;
                s_responseHeadersLoookupTable.Add(headerName, i32); 
            }
        } 
 
        // ***********************************************************************
 
        static HttpWorkerRequest() {
            //
            // common headers
            // 

            DefineHeader(true,  true,  HeaderCacheControl,        "Cache-Control",         "HTTP_CACHE_CONTROL"); 
            DefineHeader(true,  true,  HeaderConnection,          "Connection",            "HTTP_CONNECTION"); 
            DefineHeader(true,  true,  HeaderDate,                "Date",                  "HTTP_DATE");
            DefineHeader(true,  true,  HeaderKeepAlive,           "Keep-Alive",            "HTTP_KEEP_ALIVE"); 
            DefineHeader(true,  true,  HeaderPragma,              "Pragma",                "HTTP_PRAGMA");
            DefineHeader(true,  true,  HeaderTrailer,             "Trailer",               "HTTP_TRAILER");
            DefineHeader(true,  true,  HeaderTransferEncoding,    "Transfer-Encoding",     "HTTP_TRANSFER_ENCODING");
            DefineHeader(true,  true,  HeaderUpgrade,             "Upgrade",               "HTTP_UPGRADE"); 
            DefineHeader(true,  true,  HeaderVia,                 "Via",                   "HTTP_VIA");
            DefineHeader(true,  true,  HeaderWarning,             "Warning",               "HTTP_WARNING"); 
            DefineHeader(true,  true,  HeaderAllow,               "Allow",                 "HTTP_ALLOW"); 
            DefineHeader(true,  true,  HeaderContentLength,       "Content-Length",        "HTTP_CONTENT_LENGTH");
            DefineHeader(true,  true,  HeaderContentType,         "Content-Type",          "HTTP_CONTENT_TYPE"); 
            DefineHeader(true,  true,  HeaderContentEncoding,     "Content-Encoding",      "HTTP_CONTENT_ENCODING");
            DefineHeader(true,  true,  HeaderContentLanguage,     "Content-Language",      "HTTP_CONTENT_LANGUAGE");
            DefineHeader(true,  true,  HeaderContentLocation,     "Content-Location",      "HTTP_CONTENT_LOCATION");
            DefineHeader(true,  true,  HeaderContentMd5,          "Content-MD5",           "HTTP_CONTENT_MD5"); 
            DefineHeader(true,  true,  HeaderContentRange,        "Content-Range",         "HTTP_CONTENT_RANGE");
            DefineHeader(true,  true,  HeaderExpires,             "Expires",               "HTTP_EXPIRES"); 
            DefineHeader(true,  true,  HeaderLastModified,        "Last-Modified",         "HTTP_LAST_MODIFIED"); 

            // 
            // request only headers
            //

            DefineHeader(true,  false, HeaderAccept,              "Accept",                "HTTP_ACCEPT"); 
            DefineHeader(true,  false, HeaderAcceptCharset,       "Accept-Charset",        "HTTP_ACCEPT_CHARSET");
            DefineHeader(true,  false, HeaderAcceptEncoding,      "Accept-Encoding",       "HTTP_ACCEPT_ENCODING"); 
            DefineHeader(true,  false, HeaderAcceptLanguage,      "Accept-Language",       "HTTP_ACCEPT_LANGUAGE"); 
            DefineHeader(true,  false, HeaderAuthorization,       "Authorization",         "HTTP_AUTHORIZATION");
            DefineHeader(true,  false, HeaderCookie,              "Cookie",                "HTTP_COOKIE"); 
            DefineHeader(true,  false, HeaderExpect,              "Expect",                "HTTP_EXPECT");
            DefineHeader(true,  false, HeaderFrom,                "From",                  "HTTP_FROM");
            DefineHeader(true,  false, HeaderHost,                "Host",                  "HTTP_HOST");
            DefineHeader(true,  false, HeaderIfMatch,             "If-Match",              "HTTP_IF_MATCH"); 
            DefineHeader(true,  false, HeaderIfModifiedSince,     "If-Modified-Since",     "HTTP_IF_MODIFIED_SINCE");
            DefineHeader(true,  false, HeaderIfNoneMatch,         "If-None-Match",         "HTTP_IF_NONE_MATCH"); 
            DefineHeader(true,  false, HeaderIfRange,             "If-Range",              "HTTP_IF_RANGE"); 
            DefineHeader(true,  false, HeaderIfUnmodifiedSince,   "If-Unmodified-Since",   "HTTP_IF_UNMODIFIED_SINCE");
            DefineHeader(true,  false, HeaderMaxForwards,         "Max-Forwards",          "HTTP_MAX_FORWARDS"); 
            DefineHeader(true,  false, HeaderProxyAuthorization,  "Proxy-Authorization",   "HTTP_PROXY_AUTHORIZATION");
            DefineHeader(true,  false, HeaderReferer,             "Referer",               "HTTP_REFERER");
            DefineHeader(true,  false, HeaderRange,               "Range",                 "HTTP_RANGE");
            DefineHeader(true,  false, HeaderTe,                  "TE",                    "HTTP_TE"); 
            DefineHeader(true,  false, HeaderUserAgent,           "User-Agent",            "HTTP_USER_AGENT");
 
            // 
            // response only headers
            // 

            DefineHeader(false, true,  HeaderAcceptRanges,        "Accept-Ranges",         null);
            DefineHeader(false, true,  HeaderAge,                 "Age",                   null);
            DefineHeader(false, true,  HeaderEtag,                "ETag",                  null); 
            DefineHeader(false, true,  HeaderLocation,            "Location",              null);
            DefineHeader(false, true,  HeaderProxyAuthenticate,   "Proxy-Authenticate",    null); 
            DefineHeader(false, true,  HeaderRetryAfter,          "Retry-After",           null); 
            DefineHeader(false, true,  HeaderServer,              "Server",                null);
            DefineHeader(false, true,  HeaderSetCookie,           "Set-Cookie",            null); 
            DefineHeader(false, true,  HeaderVary,                "Vary",                  null);
            DefineHeader(false, true,  HeaderWwwAuthenticate,     "WWW-Authenticate",      null);
        }
    } 
}

// File provided for Reference Use Only by Microsoft Corporation (c) 2007.
// Copyright (c) Microsoft Corporation. All rights reserved.
                        

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