HttpRequest.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 / HttpRequest.cs / 10 / HttpRequest.cs

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

/* 
 * Request intrinsic 
 *
 * Copyright (c) 1998 Microsoft Corporation 
 */

namespace System.Web {
    using System; 
    using System.Text;
    using System.Configuration.Assemblies; 
    using System.Runtime.InteropServices; 
    using System.Security.Permissions;
    using System.Security.Principal; 
    using System.IO;
    using System.Collections;
    using System.Collections.Specialized;
    using System.Globalization; 
    using System.Web.Util;
    using System.Web.Hosting; 
    using System.Web.Configuration; 
    using System.Web.Management;
 
    // enumeration of dynamic server variables
    internal enum DynamicServerVariable {
        AUTH_TYPE = 1,
        AUTH_USER = 2, 
        PATH_INFO = 3,
        PATH_TRANSLATED = 4, 
        QUERY_STRING = 5, 
        SCRIPT_NAME = 6
    }; 

    internal enum HttpVerb {
        Unparsed = 0,   // must be 0 so that it's zero-init value is Unparsed
        Unknown, 
        GET,
        PUT, 
        HEAD, 
        POST,
        DEBUG, 
        DELETE,
    }

 
    /// 
    ///     
    ///       Enables 
    ///       type-safe browser to server communication. Used to gain access to HTTP request data
    ///       elements supplied by a client. 
    ///    
    /// 
    [AspNetHostingPermission(SecurityAction.LinkDemand, Level=AspNetHostingPermissionLevel.Minimal)]
    public sealed class HttpRequest { 
        // worker request
        private HttpWorkerRequest _wr; 
 
        // context
        private HttpContext _context; 

        // properties
        private String _httpMethod;
        private HttpVerb _httpVerb; 
        private String _requestType;
        private VirtualPath _path; 
        private String _rewrittenUrl; 
        private bool   _computePathInfo;
        private VirtualPath _filePath; 
        private VirtualPath _currentExecutionFilePath;
        private VirtualPath _pathInfo;
        private String _queryStringText;
        private bool   _queryStringOverriden; 
        private byte[] _queryStringBytes;
        private String _pathTranslated; 
        private String _contentType; 
        private int    _contentLength = -1;
        private String _clientTarget; 
        private String[] _acceptTypes;
        private String[] _userLanguages;
        private HttpBrowserCapabilities _browsercaps;
        private Uri _url; 
        private Uri _referrer;
        private HttpInputStream _inputStream; 
        private HttpClientCertificate _clientCertificate; 
        private WindowsIdentity _logonUserIdentity;
 
        // collections
        private HttpValueCollection _params;
        private HttpValueCollection _queryString;
        private HttpValueCollection _form; 
        private HttpHeaderCollection _headers;
        private HttpServerVarsCollection _serverVariables; 
        private HttpCookieCollection _cookies; 
        private HttpFileCollection _files;
 
        // content (to be read once)
        private HttpRawUploadedContent _rawContent;
        private bool _readEntityBody;
        private MultipartContentElement[] _multipartContentElements; 

        // encoding (for content and query string) 
        private Encoding _encoding; 

        // content filtering 
        private HttpInputStreamFilterSource _filterSource;
        private Stream _installedFilter;

        // Input validation 
        #pragma warning disable 0649
        private SimpleBitVector32 _flags; 
        #pragma warning restore 0649 
        // const masks into the BitVector32
        private const int needToValidateQueryString     = 0x0001; 
        private const int needToValidateForm            = 0x0002;
        private const int needToValidateCookies         = 0x0004;
        private const int needToValidateHeaders         = 0x0008;
        private const int needToValidateServerVariables = 0x0010; 
        private const int contentEncodingResolved       = 0x0020;
        private const int needToValidatePostedFiles     = 0x0040; 
        private const int needToValidateRawUrl          = 0x0080; 

        // Browser caps one-time evaluator objects 
        internal static object s_browserLock = new object();
        internal static bool s_browserCapsEvaled = false;

        /* 
         * Internal constructor to create requests
         * that have associated HttpWorkerRequest 
         * 
         * @param wr HttpWorkerRequest
         */ 
        internal HttpRequest(HttpWorkerRequest wr, HttpContext context) {
            _wr = wr;
            _context = context;
        } 

        /* 
         * Public constructor for request that come from arbitrary place 
         *
         * @param filename physical file name 
         * @param queryString query string
         */

        ///  
        ///    
        ///       Initializes an HttpRequest object. 
        ///     
        /// 
        public HttpRequest(String filename, String url, String queryString) { 
            _wr = null;
            _pathTranslated = filename;
            _httpMethod = "GET";
            _url = new Uri(url); 
            _path = VirtualPath.CreateAbsolute(_url.AbsolutePath);
            _queryStringText = queryString; 
            _queryStringOverriden = true; 
            _queryString = new HttpValueCollection(_queryStringText, true, true, Encoding.Default);
 
            PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_EXECUTING);

        }
 
        internal HttpRequest(VirtualPath virtualPath, String queryString) {
            _wr = null; 
            _pathTranslated = virtualPath.MapPath(); 
            _httpMethod = "GET";
            _url = new Uri("http://localhost" + virtualPath.VirtualPathString); 
            _path = virtualPath;
            _queryStringText = queryString;
            _queryStringOverriden = true;
            _queryString = new HttpValueCollection(_queryStringText, true, true, Encoding.Default); 

            PerfCounters.IncrementCounter(AppPerfCounter.REQUESTS_EXECUTING); 
        } 

        internal byte[] EntityBody { get { return _readEntityBody ? _rawContent.GetAsByteArray() : null; } } 

        internal string ClientTarget {
            get {
                return (_clientTarget == null) ? String.Empty : _clientTarget; 
            }
            set { 
                _clientTarget = value; 
                // force re-create of browser caps
                _browsercaps = null; 
            }
        }

        internal HttpContext Context { 
            get { return _context; }
            set { _context = value; } 
        } 

        /* 
         * internal response object
         */
        internal HttpResponse Response {
            get { 
                if (_context == null)
                    return null; 
                return _context.Response; 
            }
        } 

        /*
         * Internal property to determine if request is local
         */ 

        public bool IsLocal { 
            get { 
                String remoteAddress = UserHostAddress;
 
                // if unknown, assume not local
                if (String.IsNullOrEmpty(remoteAddress))
                    return false;
 
                //
                if (remoteAddress == "127.0.0.1" || remoteAddress == "::1") 
                    return true; 

                // compare with local address 
                if (remoteAddress == LocalAddress)
                    return true;

                return false; 
            }
        } 
 

        /* 
         *  Cleanup code
         */
        internal void Dispose() {
            if (_serverVariables != null) 
                _serverVariables.Dispose();  // disconnect from request
 
            if (_rawContent != null) 
                _rawContent.Dispose();  // remove temp file with uploaded content
 
        //


 

 
 
        }
 
        //
        // Misc private methods to fill in collections from HttpWorkerRequest
        // properties
        // 

        private static String[] ParseMultivalueHeader(String s) { 
            int l = (s != null) ? s.Length : 0; 
            if (l == 0)
                return null; 

            // collect comma-separated values into list

            ArrayList values = new ArrayList(); 
            int i = 0;
 
            while (i < l) { 
                // find next ,
                int ci = s.IndexOf(',', i); 
                if (ci < 0)
                    ci = l;

                // append corresponding server value 
                values.Add(s.Substring(i, ci-i));
 
                // move to next 
                i = ci+1;
 
                // skip leading space
                if (i < l && s[i] == ' ')
                    i++;
            } 

            // return list as array of strings 
 
            int n = values.Count;
            if (n == 0) 
                return null;

            String[] strings = new String[n];
            values.CopyTo(0, strings, 0, n); 
            return strings;
        } 
 
        //
        // Query string collection support 
        //

        private void FillInQueryStringCollection() {
            // try from raw bytes when available (better for globalization) 

            byte[] rawQueryString = this.QueryStringBytes; 
 
            if (rawQueryString != null) {
                if (rawQueryString.Length != 0) 
                    _queryString.FillFromEncodedBytes(rawQueryString, QueryStringEncoding);
            }
            else if (!(String.IsNullOrEmpty(this.QueryStringText))) {
                _queryString.FillFromString(this.QueryStringText, true, QueryStringEncoding); 
            }
        } 
 
        //
        // Form collection support 
        //

        private void FillInFormCollection() {
            if (_wr == null) 
                return;
 
            if (!_wr.HasEntityBody()) 
                return;
 
            String contentType = this.ContentType;
            if (contentType == null)
                return;
 
            if (StringUtil.StringStartsWithIgnoreCase(contentType, "application/x-www-form-urlencoded")) {
                // regular urlencoded form 
 
                byte[] formBytes = null;
                HttpRawUploadedContent content = GetEntireRawContent(); 

                if (content != null)
                    formBytes = content.GetAsByteArray();
 
                if (formBytes != null) {
                    try { 
                        _form.FillFromEncodedBytes(formBytes, ContentEncoding); 
                    }
                    catch (Exception e) { 
                        // could be thrown because of malformed data
                        throw new HttpException(SR.GetString(SR.Invalid_urlencoded_form_data), e);
                    }
                } 
            }
            else if (StringUtil.StringStartsWithIgnoreCase(contentType, "multipart/form-data")) { 
                // multipart form 

                MultipartContentElement[] elements = GetMultipartContent(); 

                if (elements != null) {
                    for (int i = 0; i < elements.Length; i++) {
                        if (elements[i].IsFormItem) 
                            _form.Add(elements[i].Name, elements[i].GetAsString(ContentEncoding));
                    } 
                } 
            }
        } 

        //
        // Headers collection support
        // 

        private void FillInHeadersCollection() { 
            if (_wr == null) 
                return;
 
            // known headers

            for (int i = 0; i < HttpWorkerRequest.RequestHeaderMaximum; i++) {
                String h = _wr.GetKnownRequestHeader(i); 

                if (!String.IsNullOrEmpty(h)) { 
                    String name = HttpWorkerRequest.GetKnownRequestHeaderName(i); 
                    _headers.SynchronizeHeader(name, h);
                } 
            }

            // unknown headers
 
            String[][] hh = _wr.GetUnknownRequestHeaders();
 
            if (hh != null) { 
                for (int i = 0; i < hh.Length; i++)
                    _headers.SynchronizeHeader(hh[i][0], hh[i][1]); 
            }
        }

        // 
        // Server variables collection support
        // 
 
        private static String ServerVariableNameFromHeader(String header) {
            return("HTTP_" + header.ToUpper(CultureInfo.InvariantCulture).Replace('-', '_')); 
        }

        private String CombineAllHeaders(bool asRaw) {
            if (_wr == null) 
                return String.Empty;
 
            StringBuilder sb = new StringBuilder(256); 

            // known headers 

            for (int i = 0; i < HttpWorkerRequest.RequestHeaderMaximum; i++) {
                String h = _wr.GetKnownRequestHeader(i);
 
                if (!String.IsNullOrEmpty(h)) {
                    String name; 
                    if (!asRaw) 
                        name = HttpWorkerRequest.GetServerVariableNameFromKnownRequestHeaderIndex(i);
                    else 
                        name = HttpWorkerRequest.GetKnownRequestHeaderName(i);

                    if (name != null) {
                        sb.Append(name); 
                        sb.Append(asRaw ? ": " : ":");  // for ASP compat don't add space
                        sb.Append(h); 
                        sb.Append("\r\n"); 
                    }
                } 
            }

            // unknown headers
 
            String[][] hh = _wr.GetUnknownRequestHeaders();
 
            if (hh != null) { 
                for (int i = 0; i < hh.Length; i++) {
                    String name = hh[i][0]; 

                    if (!asRaw)
                        name = ServerVariableNameFromHeader(name);
 
                    sb.Append(name);
                    sb.Append(asRaw ? ": " : ":");  // for ASP compat don't add space 
                    sb.Append(hh[i][1]); 
                    sb.Append("\r\n");
                } 
            }

            return sb.ToString();
        } 

        // callback to calculate dynamic server variable 
        internal String CalcDynamicServerVariable(DynamicServerVariable var) { 
            String value = null;
 
            switch (var) {
                case DynamicServerVariable.AUTH_TYPE:
                    if (_context.User != null && _context.User.Identity.IsAuthenticated)
                        value = _context.User.Identity.AuthenticationType; 
                    else
                        value = String.Empty; 
                    break; 
                case DynamicServerVariable.AUTH_USER:
                    if (_context.User != null && _context.User.Identity.IsAuthenticated) 
                        value = _context.User.Identity.Name;
                    else
                        value = String.Empty;
                    break; 
                case DynamicServerVariable.PATH_INFO:
                    value = this.Path; 
                    break; 
                case DynamicServerVariable.PATH_TRANSLATED:
                    value = this.PhysicalPathInternal; 
                    break;
                case DynamicServerVariable.QUERY_STRING:
                    value = this.QueryStringText;
                    break; 
                case DynamicServerVariable.SCRIPT_NAME:
                    value = this.FilePath; 
                    break; 
            }
 
            return value;
        }

        private void AddServerVariableToCollection(String name, DynamicServerVariable var) { 
            // dynamic server var
            _serverVariables.AddDynamic(name, var); 
        } 

        private void AddServerVariableToCollection(String name, String value) { 
            if (value == null)
                value = String.Empty;
            // static server var
            _serverVariables.AddStatic(name, value); 
        }
 
        private void AddServerVariableToCollection(String name) { 
            // static server var from worker request
            _serverVariables.AddStatic(name, _wr.GetServerVariable(name)); 
        }

        internal void FillInServerVariablesCollection() {
            if (_wr == null) 
                return;
 
            //  Add from hardcoded list 

            AddServerVariableToCollection("ALL_HTTP",           CombineAllHeaders(false)); 
            AddServerVariableToCollection("ALL_RAW",            CombineAllHeaders(true));

            AddServerVariableToCollection("APPL_MD_PATH");
 
            AddServerVariableToCollection("APPL_PHYSICAL_PATH", _wr.GetAppPathTranslated());
 
            AddServerVariableToCollection("AUTH_TYPE",          DynamicServerVariable.AUTH_TYPE); 
            AddServerVariableToCollection("AUTH_USER",          DynamicServerVariable.AUTH_USER);
 
            AddServerVariableToCollection("AUTH_PASSWORD");

            AddServerVariableToCollection("LOGON_USER");
            AddServerVariableToCollection("REMOTE_USER",        DynamicServerVariable.AUTH_USER); 

            AddServerVariableToCollection("CERT_COOKIE"); 
            AddServerVariableToCollection("CERT_FLAGS"); 
            AddServerVariableToCollection("CERT_ISSUER");
            AddServerVariableToCollection("CERT_KEYSIZE"); 
            AddServerVariableToCollection("CERT_SECRETKEYSIZE");
            AddServerVariableToCollection("CERT_SERIALNUMBER");
            AddServerVariableToCollection("CERT_SERVER_ISSUER");
            AddServerVariableToCollection("CERT_SERVER_SUBJECT"); 
            AddServerVariableToCollection("CERT_SUBJECT");
 
            String clString = _wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentLength); 
            AddServerVariableToCollection("CONTENT_LENGTH",     (clString != null) ? clString : "0");
 
            AddServerVariableToCollection("CONTENT_TYPE",       this.ContentType);

            AddServerVariableToCollection("GATEWAY_INTERFACE");
 
            AddServerVariableToCollection("HTTPS");
            AddServerVariableToCollection("HTTPS_KEYSIZE"); 
            AddServerVariableToCollection("HTTPS_SECRETKEYSIZE"); 
            AddServerVariableToCollection("HTTPS_SERVER_ISSUER");
            AddServerVariableToCollection("HTTPS_SERVER_SUBJECT"); 

            AddServerVariableToCollection("INSTANCE_ID");
            AddServerVariableToCollection("INSTANCE_META_PATH");
 
            AddServerVariableToCollection("LOCAL_ADDR",         _wr.GetLocalAddress());
 
            AddServerVariableToCollection("PATH_INFO",          DynamicServerVariable.PATH_INFO); 
            AddServerVariableToCollection("PATH_TRANSLATED",    DynamicServerVariable.PATH_TRANSLATED);
 
            AddServerVariableToCollection("QUERY_STRING",       DynamicServerVariable.QUERY_STRING);

            AddServerVariableToCollection("REMOTE_ADDR",        this.UserHostAddress);
            AddServerVariableToCollection("REMOTE_HOST",        this.UserHostName); 

            AddServerVariableToCollection("REMOTE_PORT"); 
 
            AddServerVariableToCollection("REQUEST_METHOD",     this.HttpMethod);
 
            AddServerVariableToCollection("SCRIPT_NAME",        DynamicServerVariable.SCRIPT_NAME);

            AddServerVariableToCollection("SERVER_NAME",        _wr.GetServerName());
            AddServerVariableToCollection("SERVER_PORT",        _wr.GetLocalPortAsString()); 

            AddServerVariableToCollection("SERVER_PORT_SECURE", _wr.IsSecure() ? "1" : "0"); 
 
            AddServerVariableToCollection("SERVER_PROTOCOL",    _wr.GetHttpVersion());
            AddServerVariableToCollection("SERVER_SOFTWARE"); 

            AddServerVariableToCollection("URL",                DynamicServerVariable.SCRIPT_NAME);

            // Add all headers in HTTP_XXX format 

            for (int i = 0; i < HttpWorkerRequest.RequestHeaderMaximum; i++) { 
                String h = _wr.GetKnownRequestHeader(i); 
                if (!String.IsNullOrEmpty(h))
                    AddServerVariableToCollection(HttpWorkerRequest.GetServerVariableNameFromKnownRequestHeaderIndex(i), h); 
            }

            String[][] hh = _wr.GetUnknownRequestHeaders();
 
            if (hh != null) {
                for (int i = 0; i < hh.Length; i++) 
                    AddServerVariableToCollection(ServerVariableNameFromHeader(hh[i][0]), hh[i][1]); 
            }
        } 

        //
        // Cookies collection support
        // 

        internal static HttpCookie CreateCookieFromString(String s) { 
            HttpCookie c = new HttpCookie(); 

            int l = (s != null) ? s.Length : 0; 
            int i = 0;
            int ai, ei;
            bool firstValue = true;
            int numValues = 1; 

            // Format: cookiename[=key1=val2&key2=val2&...] 
 
            while (i < l) {
                //  find next & 
                ai = s.IndexOf('&', i);
                if (ai < 0)
                    ai = l;
 
                // first value might contain cookie name before =
                if (firstValue) { 
                    ei = s.IndexOf('=', i); 

                    if (ei >= 0 && ei < ai) { 
                        c.Name = s.Substring(i, ei-i);
                        i = ei+1;
                    }
                    else if (ai == l) { 
                        // the whole cookie is just a name
                        c.Name = s; 
                        break; 
                    }
 
                    firstValue = false;
                }

                // find '=' 
                ei = s.IndexOf('=', i);
 
                if (ei < 0 && ai == l && numValues == 0) { 
                    // simple cookie with simple value
                    c.Value = s.Substring(i, l-i); 
                }
                else if (ei >= 0 && ei < ai) {
                    // key=value
                    c.Values.Add(s.Substring(i, ei-i), s.Substring(ei+1, ai-ei-1)); 
                    numValues++;
                } 
                else { 
                    // value without key
                    c.Values.Add(null, s.Substring(i, ai-i)); 
                    numValues++;
                }

                i = ai+1; 
            }
 
            return c; 
        }
 
        internal void FillInCookiesCollection(HttpCookieCollection cookieCollection, bool includeResponse) {
            if (_wr == null)
                return;
 
            String s = _wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderCookie);
 
            // Parse the cookie server variable. 
            // Format: c1=k1=v1&k2=v2; c2=...
 
            int l = (s != null) ? s.Length : 0;
            int i = 0;
            int j;
            char ch; 

            HttpCookie lastCookie = null; 
 
            while (i < l) {
                // find next ';' (don't look to ',' as per 91884) 
                j = i;
                while (j < l) {
                    ch = s[j];
                    if (ch == ';') 
                        break;
                    j++; 
                } 

                // create cookie form string 
                String cookieString = s.Substring(i, j-i).Trim();
                i = j+1; // next cookie start

                if (cookieString.Length == 0) 
                    continue;
 
                HttpCookie cookie = CreateCookieFromString(cookieString); 

                // some cookies starting with '$' are really attributes of the last cookie 
                if (lastCookie != null) {
                    String name = cookie.Name;

                    // add known attribute to the last cookie (if any) 
                    if (name != null && name.Length > 0 && name[0] == '$') {
                        if (StringUtil.EqualsIgnoreCase(name, "$Path")) 
                            lastCookie.Path = cookie.Value; 
                        else if (StringUtil.EqualsIgnoreCase(name, "$Domain"))
                            lastCookie.Domain = cookie.Value; 

                        continue;
                    }
                } 

                // regular cookie 
                cookieCollection.AddCookie(cookie, true); 
                lastCookie = cookie;
 
                // goto next cookie
            }

            // Append response cookies 

            if ((includeResponse) && (Response != null)) { 
                HttpCookieCollection responseCookies = Response.Cookies; 

                // 
                if (responseCookies.Count > 0) {

                    HttpCookie[] rcookies = new HttpCookie[responseCookies.Count];
                    responseCookies.CopyTo(rcookies, 0); 

                    for (int iCookie = 0; iCookie < rcookies.Length; iCookie++) 
                        cookieCollection.AddCookie(rcookies[iCookie], true); 
                }
            } 
        }

        // Params collection support
        private void FillInParamsCollection() { 
            _params.Add(this.QueryString);
            _params.Add(this.Form); 
            _params.Add(this.Cookies); 
            _params.Add(this.ServerVariables);
        } 

        //
        // Files collection support
        // 

        private void FillInFilesCollection() { 
            if (_wr == null) 
                return;
 
            if (!StringUtil.StringStartsWithIgnoreCase(ContentType, "multipart/form-data"))
                return;

            MultipartContentElement[] elements = GetMultipartContent(); 
            if (elements == null)
                return; 
 
            bool validateFileName = false;
            if (_flags[needToValidatePostedFiles]) { 
                _flags.Clear(needToValidatePostedFiles);
                validateFileName = true;
            }
            for (int i = 0; i < elements.Length; i++) { 
                if (elements[i].IsFile) {
                    HttpPostedFile p = elements[i].GetAsPostedFile(); 
                    if (validateFileName) 
                        ValidateString(p.FileName, "filename", "Request.Files");
                    _files.AddFile(elements[i].Name, p); 
                }
            }
        }
 
        //
        // Reading posted content ... 
        // 

        /* 
         * Get attribute off header value
         */
        private static String GetAttributeFromHeader(String headerValue, String attrName) {
            if (headerValue == null) 
                return null;
 
            int l = headerValue.Length; 
            int k = attrName.Length;
 
            // find properly separated attribute name
            int i = 1; // start searching from 1

            while (i < l) { 
                i = CultureInfo.InvariantCulture.CompareInfo.IndexOf(headerValue, attrName, i, CompareOptions.IgnoreCase);
                if (i < 0) 
                    break; 
                if (i+k >= l)
                    break; 

                char chPrev = headerValue[i-1];
                char chNext = headerValue[i+k];
                if ((chPrev == ';' || chPrev == ',' || Char.IsWhiteSpace(chPrev)) && (chNext == '=' || Char.IsWhiteSpace(chNext))) 
                    break;
 
                i += k; 
            }
 
            if (i < 0 || i >= l)
                return null;

            // skip to '=' and the following whitespaces 
            i += k;
            while (i < l && Char.IsWhiteSpace(headerValue[i])) 
                i++; 
            if (i >= l || headerValue[i] != '=')
                return null; 
            i++;
            while (i < l && Char.IsWhiteSpace(headerValue[i]))
                i++;
            if (i >= l) 
                return null;
 
            // parse the value 
            String attrValue = null;
 
            int j;

            if (i < l && headerValue[i] == '"') {
                if (i == l-1) 
                    return null;
                j = headerValue.IndexOf('"', i+1); 
                if (j < 0 || j == i+1) 
                    return null;
 
                attrValue = headerValue.Substring(i+1, j-i-1).Trim();
            }
            else {
                for (j = i; j < l; j++) { 
                    if (headerValue[j] == ' ' || headerValue[j] == ',')
                        break; 
                } 

                if (j == i) 
                    return null;

                attrValue = headerValue.Substring(i, j-i).Trim();
            } 

            return attrValue; 
        } 

        /* 
         * In case content-type header contains encoding it should override the config
         */
        private Encoding GetEncodingFromHeaders() {
 
            if (UserAgent != null && CultureInfo.InvariantCulture.CompareInfo.IsPrefix(UserAgent, "UP")) {
                String postDataCharset = Headers["x-up-devcap-post-charset"]; 
                if (!String.IsNullOrEmpty(postDataCharset)) { 
                    try {
                        return Encoding.GetEncoding(postDataCharset); 
                    }
                    catch {
                        // Exception may be thrown when charset is not valid.
                        // In this case, do nothing, and let the framework 
                        // use the configured RequestEncoding setting.
                    } 
                } 
            }
 

            if (!_wr.HasEntityBody())
                return null;
 
            String contentType = this.ContentType;
            if (contentType == null) 
                return null; 

            String charSet = GetAttributeFromHeader(contentType, "charset"); 
            if (charSet == null)
                return null;

            Encoding encoding = null; 

            try { 
                encoding = Encoding.GetEncoding(charSet); 
            }
            catch { 
                // bad encoding string throws an exception that needs to be consumed
            }

            return encoding; 
        }
 
        /* 
         * Read entire raw content as byte array
         */ 
        private HttpRawUploadedContent GetEntireRawContent() {
            if (_wr == null)
                return null;
 
            if (_rawContent != null)
                return _rawContent; 
 
            // enforce the limit
            HttpRuntimeSection cfg = RuntimeConfig.GetConfig(_context).HttpRuntime; 
            int limit = cfg.MaxRequestLengthBytes;
            if (ContentLength > limit) {
                if ( !(_wr is IIS7WorkerRequest) ) {
                    Response.CloseConnectionAfterError(); 
                }
                throw new HttpException(SR.GetString(SR.Max_request_length_exceeded), 
                                        null, WebEventCodes.RuntimeErrorPostTooLarge); 
            }
 
            // threshold to go to file

            int fileThreshold = cfg.RequestLengthDiskThresholdBytes;
 
            // read the preloaded content
 
            HttpRawUploadedContent rawContent = new HttpRawUploadedContent(fileThreshold, ContentLength); 

            byte[] preloadedContent = _wr.GetPreloadedEntityBody(); 

            if (preloadedContent != null) {
                _wr.UpdateRequestCounters(preloadedContent.Length);
                rawContent.AddBytes(preloadedContent, 0, preloadedContent.Length); 
            }
 
            // read the remaing content 

            if (!_wr.IsEntireEntityBodyIsPreloaded()) { 
                int remainingBytes = (ContentLength > 0) ? ContentLength - rawContent.Length : Int32.MaxValue;

                HttpApplication app = _context.ApplicationInstance;
                byte[] buf = (app != null) ? app.EntityBuffer : new byte[8 * 1024]; 
                int numBytesRead = rawContent.Length;
 
                while (remainingBytes > 0) { 
                    int bytesToRead = buf.Length;
                    if (bytesToRead > remainingBytes) 
                        bytesToRead = remainingBytes;

                    int bytesRead = _wr.ReadEntityBody(buf, bytesToRead);
                    if (bytesRead <= 0) 
                        break;
 
                    _wr.UpdateRequestCounters(bytesRead); 

                    _readEntityBody = true; 
                    rawContent.AddBytes(buf, 0, bytesRead);

                    remainingBytes -= bytesRead;
                    numBytesRead += bytesRead; 

                    if (numBytesRead > limit) { 
                        throw new HttpException(SR.GetString(SR.Max_request_length_exceeded), 
                                    null, WebEventCodes.RuntimeErrorPostTooLarge);
                    } 
                }
            }

            rawContent.DoneAddingBytes(); 

            // filter content 
 
            if (_installedFilter != null) {
                if (rawContent.Length > 0) { 
                    try {
                        try {
                            _filterSource.SetContent(rawContent);
 
                            HttpRawUploadedContent filteredRawContent = new HttpRawUploadedContent(fileThreshold, rawContent.Length);
                            HttpApplication app = _context.ApplicationInstance; 
                            byte[] buf = (app != null) ? app.EntityBuffer : new byte[8 * 1024]; 

                            for (;;) { 
                                int bytesRead = _installedFilter.Read(buf, 0, buf.Length);
                                if (bytesRead == 0)
                                    break;
                                filteredRawContent.AddBytes(buf, 0, bytesRead); 
                            }
 
                            filteredRawContent.DoneAddingBytes(); 
                            rawContent = filteredRawContent;
                        } 
                        finally {
                            _filterSource.SetContent(null);
                        }
                    } 
                    catch { // Protect against exception filters
                        throw; 
                    } 
                }
            } 

            _rawContent = rawContent;
            return _rawContent;
        } 

        /* 
         * Get multipart posted content as array of elements 
         */
        private MultipartContentElement[] GetMultipartContent() { 
            // already parsed
            if (_multipartContentElements != null)
                return _multipartContentElements;
 
            //
            byte[] boundary = GetMultipartBoundary(); 
            if (boundary == null) 
                return new MultipartContentElement[0];
 
            // read the content if not read already
            HttpRawUploadedContent content = GetEntireRawContent();
            if (content == null)
                return new MultipartContentElement[0]; 

            // do the parsing 
            _multipartContentElements = HttpMultipartContentTemplateParser.Parse(content, content.Length, boundary, ContentEncoding); 
            return _multipartContentElements;
        } 

        /*
         * Get boundary for the posted multipart content as byte array
         */ 

        private byte[] GetMultipartBoundary() { 
            // extract boundary value 
            String b = GetAttributeFromHeader(ContentType, "boundary");
            if (b == null) 
                return null;

            // prepend with "--" and convert to byte array
            b = "--" + b; 
            return Encoding.ASCII.GetBytes(b.ToCharArray());
        } 
 
        //
        // Request cookies sometimes are populated from Response 
        // Here are helper methods to do that.
        //

        /* 
         * Add response cookie to request collection (can override existing)
         */ 
        internal void AddResponseCookie(HttpCookie cookie) { 
            // cookies collection
 
            if (_cookies != null)
                _cookies.AddCookie(cookie, true);

            // cookies also go to parameters collection 

            if (_params != null) { 
                _params.MakeReadWrite(); 
                _params.Add(cookie.Name, cookie.Value);
                _params.MakeReadOnly(); 
            }
        }

        /* 
         * Clear any cookies response might've added
         */ 
        internal void ResetCookies() { 
            // cookies collection
 
            if (_cookies != null) {
                _cookies.Reset();
                FillInCookiesCollection(_cookies, true /*includeResponse*/);
            } 

            // cookies also go to parameters collection 
 
            if (_params != null) {
                _params.MakeReadWrite(); 
                _params.Reset();
                FillInParamsCollection();
                _params.MakeReadOnly();
            } 
        }
 
        /* 
         * Http method (verb) associated with the current request
         */ 

        /// 
        ///    Indicates the HTTP data transfer method used by client (GET, POST). This property is read-only.
        ///  
        public String HttpMethod {
            get { 
                // Directly from worker request 
                if (_httpMethod == null) {
                    Debug.Assert(_wr != null); 
                    _httpMethod = _wr.GetHttpVerbName();
                }

                return _httpMethod; 
            }
        } 
 
        internal HttpVerb HttpVerb {
            get { 
                if (_httpVerb == HttpVerb.Unparsed) {
                    _httpVerb = HttpVerb.Unknown;
                    string method = HttpMethod;
                    if (method != null) { 
                        switch (method.Length) {
                            case 3: 
                                if (method == "GET") { 
                                    _httpVerb = HttpVerb.GET;
                                } 
                                else if (method == "PUT") {
                                    _httpVerb = HttpVerb.PUT;
                                }
                                break; 

                            case 4: 
                                if (method == "POST") { 
                                    _httpVerb = HttpVerb.POST;
                                } 
                                else if (method == "HEAD") {
                                    _httpVerb = HttpVerb.HEAD;
                                }
                                break; 

                            case 5: 
                                if (method == "DEBUG") { 
                                    _httpVerb = HttpVerb.DEBUG;
                                } 
                                break;

                            case 6:
                                if (method == "DELETE") { 
                                    _httpVerb = HttpVerb.DELETE;
                                } 
                                break; 
                        }
                    } 
                }

                return _httpVerb;
            } 
        }
 
        // Check whether this is a DEBUG verb request 
        internal bool IsDebuggingRequest {
            get { 
                return (HttpVerb == HttpVerb.DEBUG);
            }
        }
 
        /*
         * RequestType default to verb, but can be changed 
         */ 

        ///  
        ///    Indicates the HTTP data transfer method used by client
        ///    (GET, POST).
        /// 
        public String RequestType { 
            get {
                return(_requestType != null) ? _requestType : this.HttpMethod; 
            } 

            set { 
                _requestType = value;
            }
        }
 
        /*
          * Content-type of the content posted with the current request 
          */ 

        ///  
        ///    Indicates the MIME content type of incoming request. This property is read-only.
        /// 
        public String ContentType {
            get { 
                if (_contentType == null) {
                    if (_wr != null) 
                        _contentType = _wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentType); 

                    if (_contentType == null) 
                        _contentType = String.Empty;
                }

                return _contentType; 
            }
 
            set { 
                _contentType = value;
            } 
        }


 
        /// 
        ///    Indicates the content length of incoming request. This property is read-only. 
        ///  
        public int ContentLength {
            get { 
                if (_contentLength == -1) {
                    if (_wr != null) {
                        String s = _wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderContentLength);
 
                        if (s != null) {
                            try { 
                                _contentLength = Int32.Parse(s, CultureInfo.InvariantCulture); 
                            }
                            catch { 
                            }
                        }
                        else {
                            // no content-length header, but there is data 
                            if (_wr.IsEntireEntityBodyIsPreloaded()) {
                                byte[] preloadedContent = _wr.GetPreloadedEntityBody(); 
 
                                if (preloadedContent != null)
                                    _contentLength = preloadedContent.Length; 
                            }
                        }
                    }
                } 

                return (_contentLength >= 0) ? _contentLength : 0; 
            } 
        }
 
        /*
         * Encoding to read posted text content
         */
 
        /// 
        ///    Indicates the character set of data supplied by client. This property is read-only. 
        ///  
        public Encoding ContentEncoding {
            get { 
                if(_flags[contentEncodingResolved] && _encoding != null) {
                    return _encoding;
                }
 
                _encoding = GetEncodingFromHeaders();
 
                if (_encoding == null) { 
                    // WOS 1953542: No Event Is Logged When App Config is Corrupt
                    GlobalizationSection globConfig = RuntimeConfig.GetLKGConfig(_context).Globalization; 
                    _encoding = globConfig.RequestEncoding;
                }

                _flags.Set(contentEncodingResolved); 
                return _encoding;
            } 
 
            set {
                _encoding = value; 
                _flags.Set(contentEncodingResolved);
            }
        }
 
        internal Encoding QueryStringEncoding {
            get { 
                Encoding e = ContentEncoding; 
                // query string is never unicode - use utf-8 if instead
                return e.Equals(Encoding.Unicode) ? Encoding.UTF8 : e; 
            }
        }

        /* 
         * Parsed Accept header as array of strings
         */ 
 
        /// 
        ///    Returns a string array of client-supported MIME accept types. This property is read-only. 
        /// 
        public String[] AcceptTypes {
            get {
                if (_acceptTypes == null) { 
                    if (_wr != null)
                        _acceptTypes = ParseMultivalueHeader(_wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderAccept)); 
                } 

                return _acceptTypes; 
            }
        }

        // Is the request authenticated? 
        public bool IsAuthenticated {
            get { 
                return(_context.User != null && _context.User.Identity != null && _context.User.Identity.IsAuthenticated); 
            }
        } 

        // Is using HTTPS?
        //    Indicates whether the HTTP connection is secure (that is, HTTPS). This property is read-only.
        public bool IsSecureConnection { 
            get {
                if (_wr != null) 
                    return _wr.IsSecure(); 
                else
                    return false; 
            }
        }

 
        /*
         * Virtual path corresponding to the requested Url 
         */ 

        ///  
        ///    Indicates the virtual path of the current
        ///       request, including the path PathInfo. This property is read-only.
        /// 
        public String Path { 
            get {
                return PathObject.VirtualPathString; 
            } 
        }
 
        internal VirtualPath PathObject {
            get {
                if (_path == null) {
                    // Directly from worker request 

                    Debug.Assert(_wr != null); 
 
                    // Don't allow malformed paths for security reasons
                    _path = VirtualPath.Create(_wr.GetUriPath(), 
                        VirtualPathOptions.AllowAbsolutePath);
                }

                return _path; 
            }
        } 
 

        internal string _AnonymousId = null; 

        public string AnonymousID { get { return _AnonymousId;} }

        internal String PathWithQueryString { 
            get {
                String qs = QueryStringText; 
                return (!String.IsNullOrEmpty(qs)) ? (Path + "?" + qs) : Path; 
            }
        } 

        // The virtual file path where the client browsers think we are.
        // However, in the case of cookieless session, ClientFilePath does *not* include the session id.
        private VirtualPath _clientFilePath; 

        internal VirtualPath ClientFilePath { 
            get { 
                if (_clientFilePath == null) {
                    if (_wr != null) { 
                        if (_wr.IsRewriteModuleEnabled) {
                            string uri = RawUrl;

                            // remove query string if it exists 
                            int qsIndex = uri.IndexOf('?');
                            if (qsIndex > -1) { 
                                uri = uri.Substring(0, qsIndex); 
                            }
                            _clientFilePath = VirtualPath.Create(uri, VirtualPathOptions.AllowAbsolutePath); 
                        }
                        else {
                            _clientFilePath = _wr.GetFilePathObject();
                        } 
                    }
                    else { 
                        _clientFilePath = PathObject; 
                    }
                } 
                return _clientFilePath;
            }
        }
 
        // The base dir of the client virtual file path.
        // However, in the case of cookieless session, ClientFilePath does *not* include the session id. 
        private VirtualPath _clientBaseDir; 

        // 



 

        internal VirtualPath ClientBaseDir { 
            get { 
                if (_clientBaseDir == null) {
                    // client virtual path before the last '/' 
                    if (ClientFilePath.HasTrailingSlash) {
                        _clientBaseDir = ClientFilePath;
                    }
                    else { 
                        _clientBaseDir = ClientFilePath.Parent;
                    } 
                } 

                return _clientBaseDir; 
            }
        }

        /* 
         * File path corresponding to the requested Url
         */ 
 
        /// 
        ///    Indicates the virtual path of the current request, but without the PathInfo. 
        ///         This property is read-only.
        /// 
        public String FilePath {
            get { 
                return VirtualPath.GetVirtualPathString(FilePathObject);
            } 
        } 

        internal VirtualPath FilePathObject { 
            get {
                if (_filePath != null) {
                    return _filePath;
                } 

                if (!_computePathInfo) { 
                    // Directly from worker request 

                    if (_wr != null) { 
                        _filePath = _wr.GetFilePathObject();
                        if (!_wr.IsRewriteModuleEnabled) {
                            _clientFilePath = _filePath;
                        } 
                    }
                    else { 
                        _filePath = PathObject; 
                    }
                } 
                else if (_context != null) {
                    // From config
                    //
                    //          RAID#93378 
                    //          Config system relies on FilePath for lookups so we should not
                    //          be calling it while _filePath is null or it will lead to 
                    //          infinite recursion. 
                    //
                    //          It is safe to set _filePath to Path as longer path would still 
                    //          yield correct configuration, just a little slower.

                    _filePath = PathObject;
 
                    int filePathLen = _context.GetFilePathData().Path.VirtualPathStringNoTrailingSlash.Length;
 
                    // case could be wrong in config (_path has the correct case) 

                    if (Path.Length == filePathLen) 
                        _filePath = PathObject;
                    else
                        _filePath = VirtualPath.CreateAbsolute(Path.Substring(0, filePathLen));
                } 

                return _filePath; 
            } 
        }
 
        /*
         * Normally the same as FilePath.  The difference is that when doing a
         * Server.Execute, FilePath doesn't change, while this changes to the
         * currently executing virtual path 
         */
 
        public string CurrentExecutionFilePath { 
            get {
                return CurrentExecutionFilePathObject.VirtualPathString; 
            }
        }

        internal VirtualPath CurrentExecutionFilePathObject { 
            get {
                if (_currentExecutionFilePath != null) 
                    return _currentExecutionFilePath; 

                return FilePathObject; 
            }
        }

        internal VirtualPath SwitchCurrentExecutionFilePath(VirtualPath path) { 
            VirtualPath oldPath = _currentExecutionFilePath;
            _currentExecutionFilePath = path; 
            return oldPath; 
        }
 

        // Same as CurrentExecutionFilePath, but made relative to the application root,
        // so it is application-agnostic.
        public string AppRelativeCurrentExecutionFilePath { 
            get {
                return UrlPath.MakeVirtualPathAppRelative(CurrentExecutionFilePath); 
            } 
        }
 
        // Path-info corresponding to the requested Url
        //    Indicates additional path information for a resource with a URL extension. i.e. for the URL
        //       /virdir/page.html/tail, the PathInfo value is /tail. This property is read-only.
        public String PathInfo { 
            get {
                VirtualPath pathInfoObject = PathInfoObject; 
                return pathInfoObject == null ? String.Empty : PathInfoObject.VirtualPathString; 
            }
        } 

        internal VirtualPath PathInfoObject {
            get {
                if (_pathInfo != null) { 
                    return _pathInfo;
                } 
 
                if (!_computePathInfo) {
                    // Directly from worker request 

                    if (_wr != null) {
                        _pathInfo = VirtualPath.CreateAbsoluteAllowNull(_wr.GetPathInfo());
                    } 
                }
 
                if (_pathInfo == null && _context != null) { 
                    VirtualPath path = PathObject;
                    int pathLength = path.VirtualPathString.Length; 
                    VirtualPath filePath = FilePathObject;
                    int filePathLength = filePath.VirtualPathString.Length;

                    if (filePath == null) 
                        _pathInfo = path;
                    else if (path == null || pathLength <= filePathLength) 
                        _pathInfo = null; 
                    else {
                        string pathInfoString = path.VirtualPathString.Substring(filePathLength, pathLength - filePathLength); 
                        _pathInfo = VirtualPath.CreateAbsolute(pathInfoString);
                    }
                }
 
                return _pathInfo;
            } 
        } 

 
        /*
         * Physical path corresponding to the requested Url
         */
 
        /// 
        ///    Gets the physical file system path corresponding 
        ///       to 
        ///       the requested URL. This property is read-only.
        ///  
        public String PhysicalPath {
            get {
                String path = PhysicalPathInternal;
                InternalSecurityPermissions.PathDiscovery(path).Demand(); 
                return path;
            } 
        } 

        internal String PhysicalPathInternal { 
            get {
                if (_pathTranslated == null) {
                    if (!_computePathInfo) {
                        // Directly from worker request 
                        Debug.Assert(_wr != null);
                        _pathTranslated = _wr.GetFilePathTranslated(); 
                    } 

                    if (_pathTranslated == null && _wr != null) { 
                        // Compute after rewrite
                        _pathTranslated = HostingEnvironment.MapPathInternal(FilePath);
                    }
                } 

                return _pathTranslated; 
            } 
        }
 
        /*
         * Virtual path to the application root
         */
 
        /// 
        ///    Gets the 
        ///       virtual path to the currently executing server application. 
        /// 
        public String ApplicationPath { 
            get {
                return HttpRuntime.AppDomainAppVirtualPath;
            }
        } 

        internal VirtualPath ApplicationPathObject { 
            get { 
                return HttpRuntime.AppDomainAppVirtualPathObject;
            } 
        }

        /*
         * Physical path to the application root 
         */
 
        ///  
        ///    Gets the physical
        ///       file system path of currently executing server application. 
        /// 
        public String PhysicalApplicationPath {
            get {
                InternalSecurityPermissions.AppPathDiscovery.Demand(); 

                if (_wr != null) 
                    return _wr.GetAppPathTranslated(); 
                else
                    return null; 
            }
        }

        /* 
         * User agent string
         */ 
 
        /// 
        ///    Gets the client 
        ///       browser's raw User Agent String.
        /// 
        public String UserAgent {
            get { 
                if (_wr != null)
                    return _wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderUserAgent); 
                else 
                    return null;
            } 
        }

        /*
         * Accepted user languages 
         */
 
        ///  
        ///    Gets a
        ///       sorted array of client language preferences. 
        /// 
        public String[] UserLanguages {
            get {
                if (_userLanguages == null) { 
                    if (_wr != null)
                        _userLanguages = ParseMultivalueHeader(_wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderAcceptLanguage)); 
                } 

                return _userLanguages; 
            }
        }

        // Browser caps 
        //    Provides information about incoming client's browser capabilities.
        public HttpBrowserCapabilities Browser { 
            get { 
                if(_browsercaps != null) {
                    return _browsercaps; 
                }

                if (! s_browserCapsEvaled) {
                    lock (s_browserLock) { 
                        if (! s_browserCapsEvaled) {
                            HttpCapabilitiesBase.GetBrowserCapabilities(this); 
                        } 
                        s_browserCapsEvaled = true;
                    } 
                }

                _browsercaps = (HttpBrowserCapabilities)HttpCapabilitiesBase.GetBrowserCapabilities(this);
                return _browsercaps; 
            }
 
            set { 
                _browsercaps = value;
            } 
        }

        /*
         * Client's host name 
         */
 
        ///  
        ///    Gets the
        ///       DNS name of remote client. 
        /// 
        public String UserHostName {
            get {
                String s = (_wr != null) ? _wr.GetRemoteName() : null; 
                if (String.IsNullOrEmpty(s))
                    s = UserHostAddress; 
                return s; 
            }
        } 

        /*
         * Client's host address
         */ 

        ///  
        ///    Gets the 
        ///       IP host address of remote client.
        ///  
        public String UserHostAddress {
            get {
                if (_wr != null)
                    return _wr.GetRemoteAddress(); 
                else
                    return null; 
            } 
        }
 
        internal String LocalAddress {
            get {
                if (_wr != null)
                    return _wr.GetLocalAddress(); 
                else
                    return null; 
            } 
        }
 
        /*
         * The current request's RAW Url (as supplied by worker request)
         */
 
        /// 
        ///    Gets the URI requsted by the client, which may include PathInfo and QueryString if it exists. 
        ///    This value is unaffected by any URL rewriting or routing that may occur on the server. 
        /// 
        public String RawUrl { 
            get {
                String url;

                if (_wr != null) { 
                    url = _wr.GetRawUrl();
                } 
                else { 
                    String p = this.Path;
                    String qs = this.QueryStringText; 

                    if (!String.IsNullOrEmpty(qs))
                        url = p + "?" + qs;
                    else 
                        url = p;
                } 
                if (_flags[needToValidateRawUrl]) { 
                    _flags.Clear(needToValidateRawUrl);
                    ValidateString(url, null, "Request.RawUrl"); 
                }

                return url;
            } 
        }
 
        // WOS 1953542: No Event Is Logged When App Config is Corrupt 
        // This should never throw.  Since Uri.ctor can throw if config
        // is bad, we cannot use the public Url property. 
        internal String UrlInternal {
            get {
                string q = QueryStringText;
                if (!String.IsNullOrEmpty(q)) 
                    q = "?" + HttpUtility.CollapsePercentUFromStringInternal(q, QueryStringEncoding);
                String serverName = _wr.GetServerName(); 
                if (serverName.IndexOf(':') >= 0 && serverName[0] != '[') 
                    serverName = "[" + serverName + "]"; // IPv6
                if (_wr.GetLocalPortAsString() == "80") { 
                    return _wr.GetProtocol() + "://" + serverName + Path + q;
                }
                else {
                    return _wr.GetProtocol() + "://" + serverName + ":" + _wr.GetLocalPortAsString() + Path + q; 
                }
            } 
        } 

        // The current request's Url 
        //    Gets Information regarding URL of current request.
        public Uri Url {
            get {
                if (_url == null && _wr != null) { 
                    string q = QueryStringText;
                    if (!String.IsNullOrEmpty(q)) 
                        q = "?" + HttpUtility.CollapsePercentUFromStringInternal(q, QueryStringEncoding); 
                    String serverName = _wr.GetServerName();
                    if (serverName.IndexOf(':') >= 0 && serverName[0] != '[') 
                        serverName = "[" + serverName + "]"; // IPv6

                    _url = new Uri(_wr.GetProtocol() + "://" + serverName + ":" + _wr.GetLocalPortAsString() + Path + q);
                } 

                return _url; 
            } 
        }
 
        // Url of the Http referrer
        /// Gets information regarding the URL of the client's previous request that linked to the current URL.
        public Uri UrlReferrer {
            get { 
                if (_referrer == null) {
                    if (_wr != null) { 
                        String r = _wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderReferer); 

                        if (!String.IsNullOrEmpty(r)) { 
                            try {
                                if (r.IndexOf("://", StringComparison.Ordinal) >= 0)
                                    _referrer = new Uri(r);
                                 else 
                                    _referrer = new Uri(this.Url, r);
                            } 
                            catch (HttpException) { 
                                // malformed referrer shouldn't crash the request
                                _referrer = null; 
                            }
                        }
                    }
                } 

                return _referrer; 
            } 
        }
 
        // special case for perf in output cache module
        internal String IfModifiedSince {
            get {
                if (_wr == null) 
                    return null;
                return _wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderIfModifiedSince); 
            } 
        }
 
        // special case for perf in output cache module
        internal String IfNoneMatch {
            get {
                if (_wr == null) 
                    return null;
                return _wr.GetKnownRequestHeader(HttpWorkerRequest.HeaderIfNoneMatch); 
            } 
        }
 
        // Params collection - combination of query string, form, server vars
        //    Gets a combined collection of QueryString+Form+ ServerVariable+Cookies.
        public NameValueCollection Params {
            get { 
                if (HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Low))
                    return GetParams(); 
                else 
                    return GetParamsWithDemand();
            } 
        }

        // Used in integrated pipeline mode to invalidate the params collection
        // after a change is made to the headers or server variables 
        internal void InvalidateParams() {
            _params = null; 
        } 

        private NameValueCollection GetParams() { 
            if (_params == null) {
                _params = new HttpValueCollection(64);
                FillInParamsCollection();
                _params.MakeReadOnly(); 
            }
            return _params; 
        } 

        [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Low)] 
        private NameValueCollection GetParamsWithDemand()
        {
            return GetParams();
        } 

 
        // Default property that goes through the collections 
        //      QueryString, Form, Cookies, ClientCertificate and ServerVariables
        public String this[String key] { 
            get {
                String s;

                s = QueryString[key]; 
                if (s != null)
                    return s; 
 
                s = Form[key];
                if (s != null) 
                    return s;

                HttpCookie c = Cookies[key];
                if (c != null) 
                    return c.Value;
 
                s = ServerVariables[key]; 
                if (s != null)
                    return s; 

                return null;
            }
        } 

        // Query string as String (private) 
        internal String QueryStringText { 
            get {
                if (_queryStringText == null) { 
                    if (_wr != null) {
                        // if raw bytes available use them
                        byte[] rawQueryString = this.QueryStringBytes;
 
                        if (rawQueryString != null) {
                            if (rawQueryString.Length > 0) 
                                _queryStringText = QueryStringEncoding.GetString(rawQueryString); 
                            else
                                _queryStringText = String.Empty; 
                        }
                        else {
                            _queryStringText = _wr.GetQueryString();
                        } 
                    }
 
                    if (_queryStringText == null) 
                        _queryStringText = String.Empty;
                } 

                return _queryStringText;
            }
 
            set {
                // override the query string 
                _queryStringText = value; 
                _queryStringOverriden = true;
 
                if (_queryString != null) {
                    _params=null;
                    _queryString.MakeReadWrite();
                    _queryString.Reset(); 
                    FillInQueryStringCollection();
                    _queryString.MakeReadOnly(); 
                } 
            }
        } 

        // Query string as byte[] (private) -- for parsing
        internal byte[] QueryStringBytes {
            get { 
                if (_queryStringOverriden)
                    return null; 
 
                if (_queryStringBytes == null) {
                    if (_wr != null) 
                        _queryStringBytes = _wr.GetQueryStringRawBytes();
                }

                return _queryStringBytes; 
            }
        } 
 
        // Query string collection
        //    Gets the collection of QueryString variables. 
        //
        public NameValueCollection QueryString {
            get {
                if (_queryString == null) { 
                    _queryString = new HttpValueCollection();
 
                    if (_wr != null) 
                        FillInQueryStringCollection();
 
                    _queryString.MakeReadOnly();
                }

                if (_flags[needToValidateQueryString]) { 
                    _flags.Clear(needToValidateQueryString);
                    ValidateNameValueCollection(_queryString, "Request.QueryString"); 
                } 

                return _queryString; 
            }
        }

        internal bool HasQueryString { 
            get {
                if (_queryString != null) 
                    return (_queryString.Count > 0); 

                byte[] rawQueryString = this.QueryStringBytes; 

                if (rawQueryString != null) {
                    return (rawQueryString.Length > 0);
                } 
                else {
                    return (QueryStringText.Length > 0); 
                } 
            }
        } 

        // Form collection
        ///    Gets a collection of Form variables.
        public NameValueCollection Form { 
            get {
                if (_form == null) { 
                    _form = new HttpValueCollection(); 

                    if (_wr != null) 
                        FillInFormCollection();

                    _form.MakeReadOnly();
                } 

                if (_flags[needToValidateForm]) { 
                    _flags.Clear(needToValidateForm); 
                    ValidateNameValueCollection(_form, "Request.Form");
                } 

                return _form;
            }
        } 

        internal bool HasForm { 
            get { 
                if (_form != null) {
                    return (_form.Count > 0); 
                }
                else {
                    if (_wr != null && !_wr.HasEntityBody()) {
                        return false; 
                    }
                    else { 
                        return (Form.Count > 0); 
                    }
                } 
            }
        }

 
        internal HttpValueCollection SwitchForm(HttpValueCollection form) {
            HttpValueCollection oldForm = _form; 
            _form = form; 
            return oldForm;
        } 

        // Headers collection
        //    Gets a collection of HTTP headers.
        public NameValueCollection Headers { 
            get {
                if (_headers == null) { 
                    _headers = new HttpHeaderCollection(_wr, this, 8); 

                    if (_wr != null) 
                        FillInHeadersCollection();

                    if ( !(_wr is IIS7WorkerRequest) ) {
                        _headers.MakeReadOnly(); 
                    }
                } 
 
                return _headers;
            } 
        }

        // Server vars collection
        // Gets a collection of web server variables. 
        public NameValueCollection ServerVariables {
            get { 
                if (HttpRuntime.HasAspNetHostingPermission(AspNetHostingPermissionLevel.Low)) 
                    return GetServerVars();
                else 
                    return GetServerVarsWithDemand();
            }
        }
        [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Low)] 
        private NameValueCollection GetServerVarsWithDemand()
        { 
            return GetServerVars(); 
        }
 
        private NameValueCollection GetServerVars()
        {
            if (_serverVariables == null) {
                _serverVariables = new HttpServerVarsCollection(_wr, this); 

                if ( !(_wr is IIS7WorkerRequest) ) { 
                    _serverVariables.MakeReadOnly(); 
                }
            } 
            return _serverVariables;
        }

        internal void SetSkipAuthorization(bool value) { 
            IIS7WorkerRequest wr = _wr as IIS7WorkerRequest;
            if (wr == null) { 
                return; 
            }
 
            // If value is true, set server variable to "1".
            // If value is false, remove server variable by setting value to null.
            // Don't create server variable collection if it's not created yet.
 
            if (_serverVariables == null) {
                wr.SetServerVariable("IS_LOGIN_PAGE", value ? "1" : null); 
            } 
            else {
                _serverVariables.SetNoDemand("IS_LOGIN_PAGE", value ? "1" : null); 
            }
        }

        internal void SetDynamicCompression(bool enable) { 
            IIS7WorkerRequest wr = _wr as IIS7WorkerRequest;
            if (wr == null) { 
                return; 
            }
 
            // If "enable" is true, remove server variable by setting value to null.
            // If "enable" is false, set server variable to "0" to disable.
            // Don't create server variable collection if it's not created yet.
 
            if (_serverVariables == null) {
                wr.SetServerVariable("IIS_EnableDynamicCompression", enable ? null : "0"); 
            } 
            else {
                _serverVariables.SetNoDemand("IIS_EnableDynamicCompression", enable ? null : "0"); 
            }
        }

        // WOS 1526602: ASP.Net v2.0: Response.AppendToLog does not work properly in integrated mode 
        internal void AppendToLogQueryString(string logData) {
            IIS7WorkerRequest wr = _wr as IIS7WorkerRequest; 
            if (wr == null ||  String.IsNullOrEmpty(logData)) { 
                return;
            } 

            // Don't create server variable collection if it's not created yet.
            if (_serverVariables == null) {
                string currentLogData = wr.GetServerVariable("LOG_QUERY_STRING"); 
                if (String.IsNullOrEmpty(currentLogData)) {
                    wr.SetServerVariable("LOG_QUERY_STRING", QueryStringText + logData); 
                } 
                else {
                    wr.SetServerVariable("LOG_QUERY_STRING", currentLogData + logData); 
                }
            }
            else {
                string currentLogData = _serverVariables.Get("LOG_QUERY_STRING"); 
                if (String.IsNullOrEmpty(currentLogData)) {
                    _serverVariables.SetNoDemand("LOG_QUERY_STRING", QueryStringText + logData); 
                } 
                else {
                    _serverVariables.SetNoDemand("LOG_QUERY_STRING", currentLogData + logData); 
                }
            }
        }
 
        // Cookie collection associated with current request
        //    Gets a collection of client's cookie variables. 
        public HttpCookieCollection Cookies { 
            get {
                if (_cookies == null) { 
                    _cookies = new HttpCookieCollection(null, false);

                    if (_wr != null)
                        FillInCookiesCollection(_cookies, true /*includeResponse*/); 
                }
 
                if (_flags[needToValidateCookies]) { 
                    _flags.Clear(needToValidateCookies);
                    ValidateCookieCollection(_cookies); 
                }

                return _cookies;
            } 
        }
 
        // File collection associated with current request 
        // Gets the collection of client-uploaded files (Multipart MIME format).
        public HttpFileCollection Files { 
            get {
                if (_files == null) {
                    _files = new HttpFileCollection();
 
                    if (_wr != null)
                        FillInFilesCollection(); 
                } 

                return _files; 
            }
        }

        // Stream to read raw content 
        //   Provides access to the raw contents of the incoming HTTP entity body.
        public Stream InputStream { 
            get { 
                if (_inputStream == null) {
                    HttpRawUploadedContent rawContent = null; 

                    if (_wr != null)
                        rawContent = GetEntireRawContent();
 
                    if (rawContent != null) {
                        _inputStream = new HttpInputStream( 
                                                          rawContent, 
                                                          0,
                                                          rawContent.Length 
                                                          );
                    }
                    else {
                        _inputStream = new HttpInputStream(null, 0, 0); 
                    }
                } 
 
                return _inputStream;
            } 
        }

        // ASP classic compat
        //       Gets the number of bytes in the current input stream. 
        public int TotalBytes {
            get { 
                Stream s = InputStream; 
                return(s != null) ? (int)s.Length : 0;
            } 
        }

        // ASP classic compat
        //  Performs a binary read of a specified number of bytes from the current input stream. 
        public byte[] BinaryRead(int count) {
            if (count < 0 || count > TotalBytes) 
                throw new ArgumentOutOfRangeException("count"); 

            if (count == 0) 
                return new byte[0];

            byte[] buffer = new byte[count];
            int c = InputStream.Read(buffer, 0, count); 

            if (c != count) { 
                byte[] b2 = new byte[c]; 
                if (c > 0)
                    Array.Copy(buffer, b2, c); 
                buffer = b2;
            }

            return buffer; 
        }
 
        // Filtering of the input 
        //   Gets or sets a filter to use when reading the current input stream.
        public Stream Filter { 
            get {
                if (_installedFilter != null)
                    return _installedFilter;
 
                if (_filterSource == null)
                    _filterSource = new HttpInputStreamFilterSource(); 
 
                return _filterSource;
            } 

            set {
                if (_filterSource == null)  // have to use the source -- null means source wasn't ever asked for
                    throw new HttpException(SR.GetString(SR.Invalid_request_filter)); 

                _installedFilter = value; 
            } 
        }
 

        // Client Certificate
        //    Gets information on the current request's client security certificate.
        public HttpClientCertificate ClientCertificate { 
            [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Low)]
            get { 
                if (_clientCertificate == null) { 
                    _clientCertificate = CreateHttpClientCertificateWithAssert();
                } 

                return _clientCertificate;
            }
        } 

        [PermissionSet(SecurityAction.Assert, Unrestricted=true)] 
        HttpClientCertificate CreateHttpClientCertificateWithAssert() { 
            return new HttpClientCertificate(_context);
        } 


        //    Gets LOGON_USER as WindowsIdentity
        public WindowsIdentity LogonUserIdentity { 
            [AspNetHostingPermission(SecurityAction.Demand, Level=AspNetHostingPermissionLevel.Medium)]
            get { 
                if (_logonUserIdentity == null) { 
                    if (_wr != null) {
                        if (_wr is IIS7WorkerRequest && 
                            ((_context.NotificationContext.CurrentNotification == RequestNotification.AuthenticateRequest && !_context.NotificationContext.IsPostNotification)
                             || (_context.NotificationContext.CurrentNotification < RequestNotification.AuthenticateRequest))) {
                            throw new InvalidOperationException(SR.GetString(SR.Invalid_before_authentication));
                        } 

                        IntPtr token = _wr.GetUserToken(); 
 
                        if (token != IntPtr.Zero) {
                            String logonUser = _wr.GetServerVariable("LOGON_USER"); 
                            String authType  = _wr.GetServerVariable("AUTH_TYPE");
                            bool isAuthenticated = (!string.IsNullOrEmpty(logonUser) || (!string.IsNullOrEmpty(authType) && !StringUtil.EqualsIgnoreCase(authType, "basic")));
                            _logonUserIdentity = CreateWindowsIdentityWithAssert(token, ((authType == null) ? "" : authType), WindowsAccountType.Normal, isAuthenticated);
                        } 
                    }
                } 
 
                return _logonUserIdentity;
            } 
        }
        [PermissionSet(SecurityAction.Assert, Unrestricted=true)]
        private static WindowsIdentity CreateWindowsIdentityWithAssert(IntPtr token, string authType, WindowsAccountType accountType, bool isAuthenticated)
        { 
            return new WindowsIdentity(token, authType, accountType, isAuthenticated);
        } 
 
        //  Validate that the input from the browser is safe.
        public void ValidateInput() { 
            // This is to prevent some XSS (cross site scripting) attacks (ASURT 122278)
            _flags.Set(needToValidateQueryString);
            _flags.Set(needToValidateForm);
            _flags.Set(needToValidateCookies); 
            _flags.Set(needToValidatePostedFiles);
            _flags.Set(needToValidateRawUrl); 
            // 
        }
 
        internal string ValidateRawUrl() {
            return RawUrl;
        }
 
        private static string RemoveNullCharacters(string s) {
            if (s == null) 
                return null; 

            // Ignore null characters to prevent attacks ( 
            if (s.IndexOf('\0') > -1)
                return s.Replace("\0", String.Empty);

            return s; 
        }
 
        private static void ValidateString(string s, string valueName, string collectionName) { 

            s = RemoveNullCharacters(s); 

            int matchIndex=0;
            if (CrossSiteScriptingValidation.IsDangerousString(s, out matchIndex)) {
                // Display only the piece of the string that caused the problem, padded by on each side 
                string detectedString = valueName + "=\"";
                int startIndex = matchIndex - 10; 
                if (startIndex <= 0) { 
                    startIndex = 0;
                } 
                else {
                    // Start with "..." to show that this is not the beginning
                    detectedString += "...";
                } 
                int endIndex = matchIndex + 20;
                if (endIndex >= s.Length) { 
                    endIndex = s.Length; 
                    detectedString += s.Substring(startIndex, endIndex-startIndex) + "\"";
                } 
                else {
                    detectedString += s.Substring(startIndex, endIndex-startIndex) + "...\"";
                }
                throw new HttpRequestValidationException(SR.GetString(SR.Dangerous_input_detected, 
                    collectionName, detectedString));
            } 
        } 

        private static void ValidateNameValueCollection(NameValueCollection nvc, string collectionName) { 
            int c = nvc.Count;

            for (int i = 0; i < c; i++) {
                String key = nvc.GetKey(i); 

                // Skip all our internal fields, since they don't need to be checked ( 
 

                if (key != null && key.StartsWith(System.Web.UI.Page.systemPostFieldPrefix, StringComparison.Ordinal)) { 
                     continue;
                }

                String val = nvc.Get(i); 

                if (!String.IsNullOrEmpty(val)) 
                    ValidateString(val, key, collectionName); 
            }
        } 

        private static void ValidateCookieCollection(HttpCookieCollection cc) {
            int c = cc.Count;
 
            for (int i = 0; i < c; i++) {
                String key = cc.GetKey(i); 
                String val = cc.Get(i).Value; 

                if (!String.IsNullOrEmpty(val)) 
                    ValidateString(val, key, "Request.Cookies");
            }
        }
 
        /*
         * Get coordinates of the clicked image send as name.x=&name.y= 
         * in the form or in the query string 
         * @param imageFieldName name of the image field
         * @return x,y as int[2] or null if not found 
         */

        /// 
        ///     
        ///       Maps an incoming image field form parameter into appropriate x/y
        ///       coordinate values. 
        ///     
        /// 
        public int[] MapImageCoordinates(String imageFieldName) { 
            // Select collection where to look according to verb

            NameValueCollection c = null;
 
            switch (this.HttpVerb) {
                case HttpVerb.GET: 
                case HttpVerb.HEAD: 
                    c = this.QueryString;
                    break; 

                case HttpVerb.POST:
                    c = this.Form;
                    break; 

                default: 
                    return null; 
            }
 
            // Look for .x and .y values in the collection

            int[] ret = null;
 
            try {
                String x = c[imageFieldName + ".x"]; 
                String y = c[imageFieldName + ".y"]; 

                if (x != null && y != null) 
                    ret = (new int[] { Int32.Parse(x, CultureInfo.InvariantCulture), Int32.Parse(y, CultureInfo.InvariantCulture)});
            }
            catch {
                // eat parsing exceptions 
            }
 
            return ret; 
        }
 

        /*
         * Save contents of request into a file
         * @param filename where to save 
         * @param includeHeaders flag to request inclusion of Http headers
         */ 
 
        /// 
        ///    Saves an HTTP request to disk. 
        /// 
        public void SaveAs(String filename, bool includeHeaders) {
            // NDPWhidbey 14376
            if (!System.IO.Path.IsPathRooted(filename)) { 
                HttpRuntimeSection config = RuntimeConfig.GetConfig(_context).HttpRuntime;
                if (config.RequireRootedSaveAsPath) { 
                    throw new HttpException(SR.GetString(SR.SaveAs_requires_rooted_path, filename)); 
                }
            } 

            FileStream f = new FileStream(filename, FileMode.Create);

            try { 
                // headers
 
                if (includeHeaders) { 
                    TextWriter w = new StreamWriter(f);
 
                    w.Write(this.HttpMethod + " " + this.Path);

                    String qs = this.QueryStringText;
                    if (!String.IsNullOrEmpty(qs)) 
                        w.Write("?" + qs);
 
                    if (_wr != null) { 
                        // real request -- add protocol
                        w.Write(" " + _wr.GetHttpVersion() + "\r\n"); 

                        // headers
                        w.Write(CombineAllHeaders(true));
                    } 
                    else {
                        // manufactured request 
                        w.Write("\r\n"); 
                    }
 
                    w.Write("\r\n");
                    w.Flush();
                }
 
                // entity body
 
                HttpInputStream s = (HttpInputStream)this.InputStream; 
                s.WriteTo(f);
                f.Flush(); 
            }
            finally {
                f.Close();
            } 
        }
 
        /* 
         * Map virtual path to physical path relative to current request
         * @param virtualPath virtual path (absolute or relative) 
         * @return physical path
         */

        ///  
        ///    
        ///       Maps the given virtual path to a physical path. 
        ///     
        /// 
        public String MapPath(String virtualPath) { 
            return MapPath(VirtualPath.CreateAllowNull(virtualPath));
        }

        internal String MapPath(VirtualPath virtualPath) { 
            if (_wr != null) {
                return MapPath(virtualPath, FilePathObject, true/*allowCrossAppMapping*/); 
            } 
            else {
                return virtualPath.MapPath(); 
            }
        }

 
        /// 
        ///     
        ///       Maps the given virtual path to a physical path. 
        ///    
        ///  
        public String MapPath(string virtualPath, string baseVirtualDir, bool allowCrossAppMapping) {
            VirtualPath baseVirtualDirObject;
            if (String.IsNullOrEmpty(baseVirtualDir)) {
                // If no base is passed in, use the request's base dir ( 
                baseVirtualDirObject = FilePathObject;
            } 
            else { 
                // We need to ensure a trailing slash to match v1.x behavior (
                baseVirtualDirObject = VirtualPath.CreateTrailingSlash(baseVirtualDir); 
            }

            return MapPath(VirtualPath.CreateAllowNull(virtualPath),
                baseVirtualDirObject, allowCrossAppMapping); 
        }
 
        internal String MapPath(VirtualPath virtualPath, VirtualPath baseVirtualDir, bool allowCrossAppMapping) { 
            if (_wr == null)
                throw new HttpException(SR.GetString(SR.Cannot_map_path_without_context)); 

            // treat null as "."

            // 
            if (virtualPath == null)
                virtualPath = VirtualPath.Create("."); 
 
            VirtualPath originalVirtualPath = virtualPath; // remember for patch-up at the end
 
            // Combine it with the base if one was passed in
            if (baseVirtualDir != null) {
                virtualPath = baseVirtualDir.Combine(virtualPath);
            } 

            if (!allowCrossAppMapping) 
                virtualPath.FailIfNotWithinAppRoot(); 

            string realPath = virtualPath.MapPathInternal(); 

            // patch up the result for Everett combatibility (
            if (virtualPath.VirtualPathString == "/" &&
                originalVirtualPath.VirtualPathString != "/" && 
                !originalVirtualPath.HasTrailingSlash &&
                UrlPath.PathEndsWithExtraSlash(realPath)) { 
                realPath = realPath.Substring(0, realPath.Length - 1); 
            }
 
            InternalSecurityPermissions.PathDiscovery(realPath).Demand();
            return realPath;
        }
 
        internal void InternalRewritePath(VirtualPath newPath, String newQueryString, bool rebaseClientPath) {
            // clear things that depend on path 
            _pathTranslated = null; 
            _pathInfo = null;
            _filePath = null; 
            _url = null;

            // DevDiv Bug 164390: calling the worker request's GetRawUrl method here
            // to ensure we cache the original request Url in Url Mapping scenarios. 
            if (_wr != null) {
                _wr.GetRawUrl(); 
            } 

            // remember the new path 
            _path = newPath;

            if (rebaseClientPath) {
                _clientBaseDir = null; 
                _clientFilePath = newPath;
            } 
 
            // set a flag so we compute things that depend on path by hand
            _computePathInfo = true; 

            // parse the new query string (might require config)
            if (newQueryString != null)
                this.QueryStringText = newQueryString; 

            // remember the rewritten url 
            _rewrittenUrl = _path.VirtualPathString; 
            string q = QueryStringText;
            if (!String.IsNullOrEmpty(q)) 
                _rewrittenUrl += "?" + q;

            IIS7WorkerRequest iis7WorkerRequest = _wr as IIS7WorkerRequest;
            if (iis7WorkerRequest != null) { 
                iis7WorkerRequest.RewriteNotifyPipeline(_path.VirtualPathString, newQueryString, rebaseClientPath);
            } 
        } 

        internal void InternalRewritePath(VirtualPath newFilePath, VirtualPath newPathInfo, 
            String newQueryString, bool setClientFilePath) {
            // clear things that depend on path
            _pathTranslated = (_wr != null) ? newFilePath.MapPathInternal() : null;
            _pathInfo = newPathInfo; 
            _filePath = newFilePath;
            _url = null; 
 
            // DevDiv Bug 164390: calling the worker request's GetRawUrl method here
            // to ensure we cache the original request Url in Url Mapping scenarios. 
            if (_wr != null) {
                _wr.GetRawUrl();
            }
 
            if (newPathInfo == null) {
                _path = newFilePath; 
            } 
            else {
                // Combine the file path and the pathInfo to get the path.  Note that we can't call 
                // newFilePath.Combine here, since the rules are very different here (
                string newFullPathString = newFilePath.VirtualPathStringWhicheverAvailable + "/" + newPathInfo.VirtualPathString;
                _path = VirtualPath.Create(newFullPathString);
            } 

            if (newQueryString != null) 
                this.QueryStringText = newQueryString; 

            // remember the rewritten url 
            _rewrittenUrl = _path.VirtualPathString;
            string q = QueryStringText;
            if (!String.IsNullOrEmpty(q))
                _rewrittenUrl += "?" + q; 

            // no need to calculate any paths 
            _computePathInfo = false; 

            if (setClientFilePath) { 
                _clientFilePath = newFilePath;
            }

            IIS7WorkerRequest iis7WorkerRequest = _wr as IIS7WorkerRequest; 
            if (iis7WorkerRequest != null) {
                String newPath = (_path != null && _path.VirtualPathString != null) ? _path.VirtualPathString : String.Empty; 
                iis7WorkerRequest.RewriteNotifyPipeline(newPath, newQueryString, setClientFilePath); 
            }
        } 

        internal String RewrittenUrl {
            get { return _rewrittenUrl; }
        } 

        internal string FetchServerVariable(string variable) { 
            return _wr.GetServerVariable(variable); 
        }
 
        // Used by IIS7WorkerRequest.SynchronizeServerVariables to update server variables in the collection
        internal void SynchronizeServerVariable(String name, String value) {
            if (name == "IS_LOGIN_PAGE") {
                bool skipAuth = (value != null && value != "0") ? true : false; 
                _context.SetSkipAuthorizationNoDemand(skipAuth, true /*managedOnly*/);
            } 
            // populate the server variables collection if necessary 
            HttpServerVarsCollection serverVars = ServerVariables as HttpServerVarsCollection;
            if (serverVars != null) { 
                serverVars.SynchronizeServerVariable(name, value);
            }
        }
 
        // Used by IIS7WorkerRequest.SynchronizeServerVariables to update server variables in the collection
        internal void SynchronizeHeader(String name, String value) { 
 
            // populate the headers collection if necessary
            HttpHeaderCollection headers = Headers as HttpHeaderCollection; 
            if (headers != null) {
                headers.SynchronizeHeader(name, value);
            }
 
            // if a header changes, the server variable also needs to be updated
            // populate the server variables collection if necessary 
            HttpServerVarsCollection serverVars = ServerVariables as HttpServerVarsCollection; 
            if (serverVars != null) {
                string svName = "HTTP_" + name.ToUpper(CultureInfo.InvariantCulture).Replace('-', '_'); 
                serverVars.SynchronizeServerVariable(svName, value);
            }
        }
 
    }
} 

// 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