//------------------------------------------------------------------------------

// <copyright file="HttpRequest.cs" company="Microsoft">

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

// </copyright>

//------------------------------------------------------------------------------

/*

* Request intrinsic

*

* Copyright (c) 1998 Microsoft Corporation

*/

namespace System.Web {

using System;

using System.Collections;

using System.Collections.Specialized;

using System.Configuration.Assemblies;

using System.Diagnostics.CodeAnalysis;

using System.Globalization;

using System.IO;

using System.Runtime.InteropServices;

using System.Security.Authentication.ExtendedProtection;

using System.Security.Permissions;

using System.Security.Principal;

using System.Text;

using System.Threading;

using System.Web.Configuration;

using System.Web.Hosting;

using System.Web.Management;

using System.Web.Routing;

using System.Web.Security;

using System.Web.SessionState;

using System.Web.Util;

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

}

/// <devdoc>

/// <para>

/// Enables

/// type-safe browser to server communication. Used to gain access to HTTP request data

/// elements supplied by a client.

/// </para>

/// </devdoc>

public sealed class HttpRequest {

// worker request

[DoNotReset]

private HttpWorkerRequest _wr;

// context

[DoNotReset]

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 bool _tlsTokenBindingInfoResolved;

private ITlsTokenBindingInfo _tlsTokenBindingInfo;

private WindowsIdentity _logonUserIdentity;

[DoNotReset]

private RequestContext _requestContext;

private string _rawUrl;

private Stream _readEntityBodyStream;

private ReadEntityBodyMode _readEntityBodyMode;

// collections

private UnvalidatedRequestValues _unvalidatedRequestValues;

private HttpValueCollection _params;

private HttpValueCollection _queryString;

private HttpValueCollection _form;

private HttpHeaderCollection _headers;

private HttpServerVarsCollection _serverVariables;

private HttpCookieCollection _cookies;

[DoNotReset] // we can't reset this field when transitioning to WebSockets because it's our only remaining reference to the response cookies collection

private HttpCookieCollection _storedResponseCookies;

private HttpFileCollection _files;

// content (to be read once)

private HttpRawUploadedContent _rawContent;

private bool _needToInsertEntityBody;

private MultipartContentElement[] _multipartContentElements;

// encoding (for content and query string)

private Encoding _encoding;

// content filtering

private HttpInputStreamFilterSource _filterSource;

private Stream _installedFilter;

private bool _filterApplied;

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

private const int needToValidatePath = 0x0100;

private const int needToValidatePathInfo = 0x0200;

private const int hasValidateInputBeenCalled = 0x8000;

private const int needToValidateCookielessHeader = 0x10000;

// True if granular request validation is enabled (validationmode >= 4.5); false if all collections validated eagerly.

private const int granularValidationEnabled = 0x40000000;

// True if request validation is suppressed (validationMode == 0.0); false if validation can be enabled via a call to ValidateInput().

private const int requestValidationSuppressed = unchecked((int)0x80000000);

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

*/

/// <devdoc>

/// <para>

/// Initializes an HttpRequest object.

/// </para>

/// </devdoc>

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 bool NeedToInsertEntityBody {

get { return _needToInsertEntityBody; }

set { _needToInsertEntityBody = value; }

}

internal void SetRawContent(HttpRawUploadedContent rawContent) {

Debug.Assert(rawContent != null);

if (rawContent.Length > 0) {

NeedToInsertEntityBody = true;

}

_rawContent = rawContent;

}

internal byte[] EntityBody { get { return NeedToInsertEntityBody ? _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; }

}

public RequestContext RequestContext {

get {

// Create an empty request context if we don't have one set

if (_requestContext == null) {

HttpContext context = Context ?? HttpContext.Current;

_requestContext = new RequestContext(new HttpContextWrapper(context), new RouteData());

}

return _requestContext;

}

set {

_requestContext = value;

}

}

private bool HasTransitionedToWebSocketRequest {

get {

return (Context != null && Context.HasWebSocketRequestTransitionCompleted);

}

}

/*

* internal response object

*/

internal HttpResponse Response {

get {

if (_context == null)

return null;

return _context.Response;

}

}

/*

* Public property to determine if request is local

*/

public bool IsLocal {

get {

if (_wr != null) {

return _wr.IsLocal();

}

else {

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

//

internal 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 (_readEntityBodyMode == ReadEntityBodyMode.Bufferless) {

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.ThrowIfMaxHttpCollectionKeysExceeded();

_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) {

// If we have a reference to the response cookies collection, use it directly

// rather than going through the Response object (which might not be available, e.g.

// if we have already transitioned to a WebSockets request).

HttpCookieCollection storedResponseCookies = _storedResponseCookies;

if (storedResponseCookies == null && !HasTransitionedToWebSocketRequest && Response != null) {

storedResponseCookies = Response.GetCookiesNoCreate();

}

if (storedResponseCookies != null && storedResponseCookies.Count > 0) {

if(AppSettings.AvoidDuplicatedSetCookie) {

cookieCollection.Append(storedResponseCookies);

}

else {

HttpCookie[] responseCookieArray = new HttpCookie[storedResponseCookies.Count];

storedResponseCookies.CopyTo(responseCookieArray, 0);

for (int iCookie = 0; iCookie < responseCookieArray.Length; iCookie++)

cookieCollection.AddCookie(responseCookieArray[iCookie], append: true);

}

}

// release any stored reference to the response cookie collection

_storedResponseCookies = null;

}

}

internal void StoreReferenceToResponseCookies(HttpCookieCollection responseCookies) {

_storedResponseCookies = responseCookies;

}

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

for (int i = 0; i < elements.Length; i++) {

if (elements[i].IsFile) {

HttpPostedFile p = elements[i].GetAsPostedFile();

_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 (!AppSettings.UseLegacyMultiValueHeaderHandling && 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) {

// if _rawContent was set by HttpBufferlessInputStream, then we will apply the filter here

if (_installedFilter != null && !_filterApplied) {

ApplyFilter(ref _rawContent, RuntimeConfig.GetConfig(_context).HttpRuntime.RequestLengthDiskThresholdBytes);

}

return _rawContent;

}

if (_readEntityBodyMode == ReadEntityBodyMode.None) {

_readEntityBodyMode = ReadEntityBodyMode.Classic;

}

else if (_readEntityBodyMode == ReadEntityBodyMode.Buffered) {

// _rawContent should have been set already

throw new InvalidOperationException(SR.GetString(SR.Invalid_operation_with_get_buffered_input_stream));

}

else if (_readEntityBodyMode == ReadEntityBodyMode.Bufferless) {

throw new HttpException(SR.GetString(SR.Incompatible_with_get_bufferless_input_stream));

}

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