We need you! We're working hard on the next version of Developer Fusion - Let us know what you think we should be up to!

The Labs \ Source Viewer \ SSCLI \ System.Net \ Booleans

SSCLI

//------------------------------------------------------------------------------
// <copyright file="HttpWebRequest.cs" company="Microsoft">
//
//
// The use and distribution terms for this software are contained in the file
// named license.txt, which can be found in the root of this distribution.
// By using this software in any fashion, you are agreeing to be bound by the
// terms of this license.
//
// You must not remove this notice, or any other, from this software.
//
// </copyright>
//------------------------------------------------------------------------------
namespace System.Net
{
using System.Collections;
using System.Collections.Specialized;
using System.Globalization;
using System.IO;
using System.IO.Compression;
using System.Net.Cache;
using System.Net.Configuration;
using System.Runtime.Serialization;
using System.Security;
using System.Security.Cryptography.X509Certificates;
using System.Security.Permissions;
using System.Text;
using System.Text.RegularExpressions;
using System.Threading;
using System.Net.Security;
using System.Reflection;
using System.ComponentModel;
/// <devdoc>
/// <para>
/// <see cref='System.Net.HttpWebRequest'/> is an HTTP-specific implementation of the <see cref='System.Net.WebRequest'/> class.
///
/// Performs the major body of HTTP request processing. Handles
/// everything between issuing the HTTP header request to parsing the
/// the HTTP response. At that point, we hand off the request to the response
/// object, where the programmer can query for headers or continue reading, usw.
/// </para>
/// </devdoc>
[Flags()]
public enum DecompressionMethods
{
None = 0,
GZip = 1,
Deflate = 2
}
[Serializable()]
public class HttpWebRequest : WebRequest, ISerializable
{
//these could have race conditions
bool m_Saw100Continue;
bool m_KeepAlive = true;
bool m_LockConnection;
bool m_NtlmKeepAlive;
bool m_PreAuthenticate;
DecompressionMethods m_AutomaticDecompression;
private static class AbortState
{
public const int Public = 1;
public const int Internal = 2;
}
// interlocked
private int m_Aborted;
//
// This is set on failure of the request before reattempting a retransmit,
// we do this on write/read failures so that we can recover from certain failures
// that may be caused by intermittent server/network failures.
// Returns: true, if we have seen some kind of failure.
//
// set to true if this request failed during a connect
bool m_OnceFailed;
bool m_Pipelined = true;
bool m_Retry = true;
bool m_HeadersCompleted;
bool m_IsCurrentAuthenticationStateProxy;
bool m_SawInitialResponse;
bool m_BodyStarted;
bool m_RequestSubmitted;
bool m_OriginallyBuffered;
bool m_Extra401Retry;
//these should be safe.
[Flags()]
private enum Booleans : uint
{
AllowAutoRedirect = 1,
AllowWriteStreamBuffering = 2,
ExpectContinue = 4,
ProxySet = 16,
UnsafeAuthenticatedConnectionSharing = 64,
IsVersionHttp10 = 128,
SendChunked = 256,
EnableDecompression = 512,
IsTunnelRequest = 1024,
Default = AllowAutoRedirect | AllowWriteStreamBuffering | ExpectContinue
}
internal const HttpStatusCode MaxOkStatus = (HttpStatusCode)299;
private const HttpStatusCode MaxRedirectionStatus = (HttpStatusCode)399;
private const int RequestLineConstantSize = 12;
private const string ContinueHeader = "100-continue";
internal const string ChunkedHeader = "chunked";
internal const string GZipHeader = "gzip";
internal const string DeflateHeader = "deflate";
// default delay on the Stream.Read and Stream.Write operations
private const int DefaultReadWriteTimeout = 5 * 60 * 1000;
// 5 minutes
// time delay that we would wait for continue
internal const int DefaultContinueTimeout = 350;
// ms
// Size of ' HTTP/x.x\r\n'
// which are the
// unchanging pieces of the
// request line.
private static readonly byte[] HttpBytes = new byte[] {(byte)'H', (byte)'T', (byte)'T', (byte)'P', (byte)'/'};
// Statics used in the 100 Continue timeout mechanism.
private static readonly WaitCallback s_EndWriteHeaders_Part2Callback = new WaitCallback(EndWriteHeaders_Part2Wrapper);
private static readonly TimerThread.Callback s_ContinueTimeoutCallback = new TimerThread.Callback(ContinueTimeoutCallback);
private static readonly TimerThread.Queue s_ContinueTimerQueue = TimerThread.GetOrCreateQueue(DefaultContinueTimeout);
private static readonly TimerThread.Callback s_TimeoutCallback = new TimerThread.Callback(TimeoutCallback);
private static readonly WaitCallback s_AbortWrapper = new WaitCallback(AbortWrapper);
private static int s_UniqueGroupId;
private Booleans _Booleans = Booleans.Default;
private DateTime _CachedIfModifedSince = DateTime.MinValue;
// Used in the 100 Continue timeout mechanism.
private TimerThread.Timer m_ContinueTimer;
private InterlockedGate m_ContinueGate;
// Holds a WriteStream result to be processed by GetResponse.
private object m_PendingReturnResult;
// Read and Write async results - corspond to BeginGetResponse(read), and BeginGetRequestStream(write)
private LazyAsyncResult _WriteAResult;
private LazyAsyncResult _ReadAResult;
// Used by our Connection to block the Request on getting a Connection
private LazyAsyncResult _ConnectionAResult;
// Used by our Connection to block on being able to Read from our Connection
private LazyAsyncResult _ConnectionReaderAResult;
// Once set, the Request either works Async or Sync internally
private TriState _RequestIsAsync;
// Delegate that can be called on Continue Response
private HttpContinueDelegate _ContinueDelegate;
// Link back to the server point used for this request.
internal ServicePoint _ServicePoint;
// this is generated by SetResponse
internal HttpWebResponse _HttpResponse;
// set by Connection code upon completion (can be either CoreResponseData or an Exception)
private object _CoreResponse;
private int _NestedWriteSideCheck;
//To keep track nested responses for Sync case
// request values
private KnownHttpVerb _Verb;
// the actual verb set by caller or default
private KnownHttpVerb _OriginVerb;
// our HTTP header response, request, parsing and storage objects
private WebHeaderCollection _HttpRequestHeaders;
// send buffer for output request with headers.
private byte[] _WriteBuffer;
// Property to set whether writes can be handled
private HttpWriteMode _HttpWriteMode;
// the host, port, and path
private Uri _Uri;
// the origin Uri host, port and path that never changes
private Uri _OriginUri;
// for which response ContentType we will look for and parse the CharacterSet
private string _MediaType;
// content length
private long _ContentLength;
// proxy that we are using...
private IWebProxy _Proxy;
private ProxyChain _ProxyChain;
private string _ConnectionGroupName;
private bool m_InternalConnectionGroup;
private AuthenticationState _ProxyAuthenticationState;
private AuthenticationState _ServerAuthenticationState;
private ICredentials _AuthInfo;
private HttpAbortDelegate _AbortDelegate;
//
// used to prevent Write Buffering,
// used otherwise for reposting POST, and PUTs in redirects
//
private ConnectStream _SubmitWriteStream;
private ConnectStream _OldSubmitWriteStream;
private int _MaximumAllowedRedirections;
private int _AutoRedirects;
//
// generic version of _AutoRedirects above
// used to count the number of requests made off this WebRequest
//
private int _RerequestCount;
//
// Timeout in milliseconds, if a synchronous request takes longer
// than timeout, a WebException is thrown
//
private int _Timeout;
//
// Used to track relative time out across the use of the request
//
private TimerThread.Timer _Timer;
//
// Timer factory, tied to the _Timeout time.
//
private TimerThread.Queue _TimerQueue;
private int _RequestContinueCount;
//
// Timeout for Read & Write on the Stream that we return through
// GetResponse().GetResponseStream() && GetRequestStream()
//
private int _ReadWriteTimeout;
private CookieContainer _CookieContainer;
private int _MaximumResponseHeadersLength;
private UnlockConnectionDelegate _UnlockDelegate;
// size of post data, that needs to be greater, before we wait for a continue response
// private static int DefaultRequireWaitForContinueSize = 2048; // bytes
//
// Properties
//
internal TimerThread.Timer RequestTimer {
get { return _Timer; }
}
internal bool Aborted {
get { return m_Aborted != 0; }
}
/// <devdoc>
/// <para>
/// Enables or disables automatically following redirection responses.
/// </para>
/// </devdoc>
public bool AllowAutoRedirect {
get { return (_Booleans & Booleans.AllowAutoRedirect) != 0; }
set {
if (value) {
_Booleans |= Booleans.AllowAutoRedirect;
}
else {
_Booleans &= ~Booleans.AllowAutoRedirect;
}
}
}
/// <devdoc>
/// <para>
/// Enables or disables buffering the data stream sent to the server.
/// </para>
/// </devdoc>
public bool AllowWriteStreamBuffering {
get { return (_Booleans & Booleans.AllowWriteStreamBuffering) != 0; }
set {
if (value) {
_Booleans |= Booleans.AllowWriteStreamBuffering;
}
else {
_Booleans &= ~Booleans.AllowWriteStreamBuffering;
}
}
}
private bool ExpectContinue {
get { return (_Booleans & Booleans.ExpectContinue) != 0; }
set {
if (value) {
_Booleans |= Booleans.ExpectContinue;
}
else {
_Booleans &= ~Booleans.ExpectContinue;
}
}
}
/// <devdoc>
/// <para>
/// Returns <see langword='true'/> if a response has been received from the
/// server.
/// </para>
/// </devdoc>
public bool HaveResponse {
get { return _ReadAResult != null && _ReadAResult.InternalPeekCompleted; }
}
// this overrides the public KeepAlive setting.
// we use this override for NTLM only
internal bool NtlmKeepAlive {
get { return m_NtlmKeepAlive; }
set { m_NtlmKeepAlive = value; }
}
internal bool SawInitialResponse {
get {
GlobalLog.Print("HttpWebRequest#" + ValidationHelper.HashString(this) + "::SawInitialResponse_get() :" + m_SawInitialResponse);
return m_SawInitialResponse;
}
set {
GlobalLog.Print("HttpWebRequest#" + ValidationHelper.HashString(this) + "::SawInitialResponse_set() :" + value);
m_SawInitialResponse = value;
}
}
internal bool BodyStarted {
get { return m_BodyStarted; }
}
/*
Accessor: KeepAlive
To the app, this means "I want to use a persistent connection if
available" if set to true, or "I don't want to use a persistent
connection", if set to false.
This accessor allows the application simply to register its
desires so far as persistence is concerned. We will act on this
and the pipelined requirement (below) at the point that we come
to choose or create a connection on the application's behalf
Read: returns the sense of the keep-alive request switch
Write: set the sense of the keep-alive request switch
*/
/// <devdoc>
/// <para>
/// Gets or sets the value of the Keep-Alive header.
/// </para>
/// </devdoc>
public bool KeepAlive {
get { return m_KeepAlive; }
set { m_KeepAlive = value; }
}
//
// LockConnection - set to true when the
// request needs exclusive access to the Connection
//
internal bool LockConnection {
get { return m_LockConnection; }
set { m_LockConnection = value; }
}
/*
Accessor: Pipelined
To the app, this means "I want to use pipelining if available" if
set to true, or "I don't want to use pipelining", if set to false.
We could infer the state of the keep-alive flag from this setting
too, but we will decide that only at connection-initiation time.
If the application sets pipelining but resets keep-alive then we
will generate a non-pipelined, non-keep-alive request
Read: returns the sense of the pipelined request switch
Write: sets the sense of the pipelined request switch
*/
/// <devdoc>
/// <para>
/// Gets or sets the value of Pipelined property.
/// </para>
/// </devdoc>
public bool Pipelined {
get { return m_Pipelined; }
set { m_Pipelined = value; }
}
/// <devdoc>
/// <para>
/// Enables or disables pre-authentication.
/// </para>
/// </devdoc>
public override bool PreAuthenticate {
get { return m_PreAuthenticate; }
set { m_PreAuthenticate = value; }
}
private bool ProxySet {
get { return (_Booleans & Booleans.ProxySet) != 0; }
set {
if (value) {
_Booleans |= Booleans.ProxySet;
}
else {
_Booleans &= ~Booleans.ProxySet;
}
}
}
private bool RequestSubmitted {
get { return m_RequestSubmitted; }
}
// Call under lock.
private bool SetRequestSubmitted()
{
bool ret = RequestSubmitted;
m_RequestSubmitted = true;
GlobalLog.Print("HttpWebRequest#" + ValidationHelper.HashString(this) + "::SetRequestSubmitted() returning:" + ret.ToString());
return ret;
}
//
// if the 100 Continue comes in around 350ms there might be race conditions
// that make us set Understands100Continue to true when parsing the 100 response
// in the Connection object and later make us set it to false if the
// thread that is waiting comes in later than 350ms. to solve this we save info
// on wether we did actually see the 100 continue. In that case, even if there's a
// timeout, we won't set it to false.
//
internal bool Saw100Continue {
get { return m_Saw100Continue; }
set { m_Saw100Continue = value; }
}
/// <devdoc>
/// <para>Allows hi-speed NTLM connection sharing with keep-alive</para>
/// </devdoc>
public bool UnsafeAuthenticatedConnectionSharing {
get { return (_Booleans & Booleans.UnsafeAuthenticatedConnectionSharing) != 0; }
set {
ExceptionHelper.WebPermissionUnrestricted.Demand();
if (value) {
_Booleans |= Booleans.UnsafeAuthenticatedConnectionSharing;
}
else {
_Booleans &= ~Booleans.UnsafeAuthenticatedConnectionSharing;
}
}
}
//
// When authenticating TO THE proxy we create a shared connection
//
internal bool UnsafeOrProxyAuthenticatedConnectionSharing {
get { return m_IsCurrentAuthenticationStateProxy || UnsafeAuthenticatedConnectionSharing; }
}
// HTTP version of the request
private bool IsVersionHttp10 {
get { return (_Booleans & Booleans.IsVersionHttp10) != 0; }
set {
if (value) {
_Booleans |= Booleans.IsVersionHttp10;
}
else {
_Booleans &= ~Booleans.IsVersionHttp10;
}
}
}
//
// SendChunked - set/gets the state of chunk transfer send mode,
// if true, we will attempt to upload/write bits using chunked property
//
/// <devdoc>
/// <para>
/// Enable and disable sending chunked data to the server.
/// </para>
/// </devdoc>
public bool SendChunked {
get { return (_Booleans & Booleans.SendChunked) != 0; }
set {
if (RequestSubmitted) {
throw new InvalidOperationException(SR.GetString(SR.net_writestarted));
}
if (value) {
_Booleans |= Booleans.SendChunked;
}
else {
_Booleans &= ~Booleans.SendChunked;
}
}
}
public DecompressionMethods AutomaticDecompression {
get { return m_AutomaticDecompression; }
set {
if (RequestSubmitted) {
throw new InvalidOperationException(SR.GetString(SR.net_writestarted));
}
m_AutomaticDecompression = value;
}
}
/*
//
internal DecompressionMethods DecompressionMethod{
get{
DecompressionMethods method = DecompressionMethods.None;
string acceptEncoding = Headers[HttpKnownHeaderNames.AcceptEncoding];
if (acceptEncoding != null){
if((AutomaticDecompression & DecompressionMethods.GZip) != 0){
method = DecompressionMethods.GZip;
}
//was it set directly?
else if(acceptEncoding.IndexOf(HttpWebRequest.GZipHeader) != -1) {
method=DecompressionMethods.GZip;
}
if (acceptEncoding.IndexOf(HttpWebRequest.DeflateHeader) != -1){
method |= DecompressionMethods.Deflate;
}
}
return method;
}
}
*/
// This property holds our actual behaviour.
// In some cases we might have to disable chunking even if the user has requested it.
// In this case SendChunked returns true, but HttpWriteMode is != HttpWriteMode.Chunked
internal HttpWriteMode HttpWriteMode {
get { return _HttpWriteMode; }
set { _HttpWriteMode = value; }
}
internal string AuthHeader(HttpResponseHeader header)
{
if (_HttpResponse == null) {
return null;
}
// currently if'd out in HttpWebRequest.cs
return _HttpResponse.Headers[(int)header];
}
// This is a shortcut that would set the default policy for HTTP/HTTPS.
// The default policy is overridden by any prefix-registered policy.
// Will demand permission for set{}
public