linux-packaging-mono/mcs/class/System/System.Net/HttpWebRequest.cs

//
// System.Net.HttpWebRequest
//
// Authors:
// 	Lawrence Pit (loz@cable.a2000.nl)
// 	Gonzalo Paniagua Javier (gonzalo@ximian.com)
//      Martin Baulig <mabaul@microsoft.com>
//
// (c) 2002 Lawrence Pit
// (c) 2003 Ximian, Inc. (http://www.ximian.com)
// (c) 2004 Novell, Inc. (http://www.novell.com)
// Copyright (c) 2017 Xamarin Inc. (http://www.xamarin.com)
//

//
// Permission is hereby granted, free of charge, to any person obtaining
// a copy of this software and associated documentation files (the
// "Software"), to deal in the Software without restriction, including
// without limitation the rights to use, copy, modify, merge, publish,
// distribute, sublicense, and/or sell copies of the Software, and to
// permit persons to whom the Software is furnished to do so, subject to
// the following conditions:
// 
// The above copyright notice and this permission notice shall be
// included in all copies or substantial portions of the Software.
// 
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
// EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
// MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
// NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
// LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
// OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
// WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
//
#if SECURITY_DEP
#if MONO_SECURITY_ALIAS
extern alias MonoSecurity;
using MonoSecurity::Mono.Security.Interface;
#else
using Mono.Security.Interface;
#endif
#endif

using System;
using System.Collections;
using System.Configuration;
using System.Globalization;
using System.IO;
using System.Net;
using System.Net.Cache;
using System.Net.Sockets;
using System.Net.Security;
using System.Runtime.Remoting.Messaging;
using System.Runtime.Serialization;
using System.Security.Cryptography.X509Certificates;
using System.Text;
using System.Threading;
using System.Threading.Tasks;
using Mono.Net.Security;

namespace System.Net
{
	[Serializable]
	public class HttpWebRequest : WebRequest, ISerializable
	{
		Uri requestUri;
		Uri actualUri;
		bool hostChanged;
		bool allowAutoRedirect = true;
		bool allowBuffering = true;
		bool allowReadStreamBuffering;
		X509CertificateCollection certificates;
		string connectionGroup;
		bool haveContentLength;
		long contentLength = -1;
		HttpContinueDelegate continueDelegate;
		CookieContainer cookieContainer;
		ICredentials credentials;
		bool haveResponse;
		bool requestSent;
		WebHeaderCollection webHeaders;
		bool keepAlive = true;
		int maxAutoRedirect = 50;
		string mediaType = String.Empty;
		string method = "GET";
		string initialMethod = "GET";
		bool pipelined = true;
		bool preAuthenticate;
		bool usedPreAuth;
		Version version = HttpVersion.Version11;
		bool force_version;
		Version actualVersion;
		IWebProxy proxy;
		bool sendChunked;
		ServicePoint servicePoint;
		int timeout = 100000;
		int continueTimeout = 350;

		WebRequestStream writeStream;
		HttpWebResponse webResponse;
		WebCompletionSource responseTask;
		WebOperation currentOperation;
		int aborted;
		bool gotRequestStream;
		int redirects;
		bool expectContinue;
		bool getResponseCalled;
		object locker = new object ();
		bool finished_reading;
		DecompressionMethods auto_decomp;
		int maxResponseHeadersLength;
		static int defaultMaxResponseHeadersLength;
		static int defaultMaximumErrorResponseLength;
		static RequestCachePolicy defaultCachePolicy;
		int readWriteTimeout = 300000; // ms
#if SECURITY_DEP
		MonoTlsProvider tlsProvider;
		MonoTlsSettings tlsSettings;
#endif
		ServerCertValidationCallback certValidationCallback;

		// stores the user provided Host header as Uri. If the user specified a default port explicitly we'll lose
		// that information when converting the host string to a Uri. _HostHasPort will store that information.
		bool hostHasPort;
		Uri hostUri;

		enum NtlmAuthState
		{
			None,
			Challenge,
			Response
		}
		AuthorizationState auth_state, proxy_auth_state;

		[NonSerialized]
		internal Func<Stream, Task> ResendContentFactory;

		// Constructors
		static HttpWebRequest ()
		{
			defaultMaxResponseHeadersLength = 64;
			defaultMaximumErrorResponseLength = 64;
			defaultCachePolicy = new RequestCachePolicy (RequestCacheLevel.BypassCache);
#if !MOBILE
#pragma warning disable 618
			NetConfig config = ConfigurationSettings.GetConfig ("system.net/settings") as NetConfig;
#pragma warning restore 618
			if (config != null)
				defaultMaxResponseHeadersLength = config.MaxResponseHeadersLength;
#endif
		}

#if MOBILE
		public
#else
		internal
#endif
		HttpWebRequest (Uri uri)
		{
			this.requestUri = uri;
			this.actualUri = uri;
			this.proxy = InternalDefaultWebProxy;
			this.webHeaders = new WebHeaderCollection (WebHeaderCollectionType.HttpWebRequest);
			ThrowOnError = true;
			ResetAuthorization ();
		}

#if SECURITY_DEP
		internal HttpWebRequest (Uri uri, MonoTlsProvider tlsProvider, MonoTlsSettings settings = null)
			: this (uri)
		{
			this.tlsProvider = tlsProvider;
			this.tlsSettings = settings;
		}
#endif

		[Obsolete ("Serialization is obsoleted for this type.  http://go.microsoft.com/fwlink/?linkid=14202")]
		protected HttpWebRequest (SerializationInfo serializationInfo, StreamingContext streamingContext)
		{
			// In CoreFX, attempting to serialize this class fails due to
			// non-serializable fields, so this constructor never gets called.
			// They're throwing PlatformNotSupportedException() in here.
			throw new SerializationException ();
		}

#if MONO_WEB_DEBUG
		static int nextId;
		internal readonly int ID = ++nextId;
#else
		internal readonly int ID;
#endif

		void ResetAuthorization ()
		{
			auth_state = new AuthorizationState (this, false);
			proxy_auth_state = new AuthorizationState (this, true);
		}

		// Properties

		void SetSpecialHeaders (string HeaderName, string value)
		{
			value = WebHeaderCollection.CheckBadChars (value, true);
			webHeaders.RemoveInternal (HeaderName);
			if (value.Length != 0) {
				webHeaders.AddInternal (HeaderName, value);
			}
		}

		public string Accept {
			get { return webHeaders["Accept"]; }
			set {
				CheckRequestStarted ();
				SetSpecialHeaders ("Accept", value);
			}
		}

		public Uri Address {
			get { return actualUri; }
			internal set { actualUri = value; } // Used by Ftp+proxy
		}

		public virtual bool AllowAutoRedirect {
			get { return allowAutoRedirect; }
			set { this.allowAutoRedirect = value; }
		}

		public virtual bool AllowWriteStreamBuffering {
			get { return allowBuffering; }
			set { allowBuffering = value; }
		}

		public virtual bool AllowReadStreamBuffering {
			get { return allowReadStreamBuffering; }
			set { allowReadStreamBuffering = value; }
		}

		static Exception GetMustImplement ()
		{
			return new NotImplementedException ();
		}

		public DecompressionMethods AutomaticDecompression {
			get {
				return auto_decomp;
			}
			set {
				CheckRequestStarted ();
				auto_decomp = value;
			}
		}

		internal bool InternalAllowBuffering {
			get {
				return allowBuffering && MethodWithBuffer;
			}
		}

		bool MethodWithBuffer {
			get {
				return method != "HEAD" && method != "GET" &&
				method != "MKCOL" && method != "CONNECT" &&
				method != "TRACE";
			}
		}

#if SECURITY_DEP
		internal MonoTlsProvider TlsProvider {
			get { return tlsProvider; }
		}

		internal MonoTlsSettings TlsSettings {
			get { return tlsSettings; }
		}
#endif

		public X509CertificateCollection ClientCertificates {
			get {
				if (certificates == null)
					certificates = new X509CertificateCollection ();
				return certificates;
			}
			set {
				if (value == null)
					throw new ArgumentNullException ("value");
				certificates = value;
			}
		}

		public string Connection {
			get { return webHeaders["Connection"]; }
			set {
				CheckRequestStarted ();

				if (string.IsNullOrWhiteSpace (value)) {
					webHeaders.RemoveInternal ("Connection");
					return;
				}

				string val = value.ToLowerInvariant ();
				if (val.Contains ("keep-alive") || val.Contains ("close"))
					throw new ArgumentException (SR.net_connarg, nameof (value));

				string checkedValue = HttpValidationHelpers.CheckBadHeaderValueChars (value);
				webHeaders.CheckUpdate ("Connection", checkedValue);
			}
		}

		public override string ConnectionGroupName {
			get { return connectionGroup; }
			set { connectionGroup = value; }
		}

		public override long ContentLength {
			get { return contentLength; }
			set {
				CheckRequestStarted ();
				if (value < 0)
					throw new ArgumentOutOfRangeException ("value", "Content-Length must be >= 0");

				contentLength = value;
				haveContentLength = true;
			}
		}

		internal long InternalContentLength {
			set { contentLength = value; }
		}

		internal bool ThrowOnError { get; set; }

		public override string ContentType {
			get { return webHeaders["Content-Type"]; }
			set {
				SetSpecialHeaders ("Content-Type", value);
			}
		}

		public HttpContinueDelegate ContinueDelegate {
			get { return continueDelegate; }
			set { continueDelegate = value; }
		}

		virtual
		public CookieContainer CookieContainer {
			get { return cookieContainer; }
			set { cookieContainer = value; }
		}

		public override ICredentials Credentials {
			get { return credentials; }
			set { credentials = value; }
		}
		public DateTime Date {
			get {
				string date = webHeaders["Date"];
				if (date == null)
					return DateTime.MinValue;
				return DateTime.ParseExact (date, "r", CultureInfo.InvariantCulture).ToLocalTime ();
			}
			set {
				SetDateHeaderHelper ("Date", value);
			}
		}

		void SetDateHeaderHelper (string headerName, DateTime dateTime)
		{
			if (dateTime == DateTime.MinValue)
				SetSpecialHeaders (headerName, null); // remove header
			else
				SetSpecialHeaders (headerName, HttpProtocolUtils.date2string (dateTime));
		}

#if !MOBILE
		[MonoTODO]
		public static new RequestCachePolicy DefaultCachePolicy {
			get { return defaultCachePolicy; }
			set { defaultCachePolicy = value; }
		}
#endif

		[MonoTODO]
		public static int DefaultMaximumErrorResponseLength {
			get { return defaultMaximumErrorResponseLength; }
			set { defaultMaximumErrorResponseLength = value; }
		}

		public string Expect {
			get { return webHeaders["Expect"]; }
			set {
				CheckRequestStarted ();
				string val = value;
				if (val != null)
					val = val.Trim ().ToLower ();

				if (val == null || val.Length == 0) {
					webHeaders.RemoveInternal ("Expect");
					return;
				}

				if (val == "100-continue")
					throw new ArgumentException ("100-Continue cannot be set with this property.",
								     "value");

				webHeaders.CheckUpdate ("Expect", value);
			}
		}

		virtual
		public bool HaveResponse {
			get { return haveResponse; }
		}

		public override WebHeaderCollection Headers {
			get { return webHeaders; }
			set {
				CheckRequestStarted ();

				WebHeaderCollection webHeaders = value;
				WebHeaderCollection newWebHeaders = new WebHeaderCollection (WebHeaderCollectionType.HttpWebRequest);

				// Copy And Validate -
				// Handle the case where their object tries to change
				//  name, value pairs after they call set, so therefore,
				//  we need to clone their headers.
				//

				foreach (String headerName in webHeaders.AllKeys) {
					newWebHeaders.Add (headerName, webHeaders[headerName]);
				}

				this.webHeaders = newWebHeaders;
			}
		}

		public string Host {

			get {
				Uri uri = hostUri ?? Address;
				return (hostUri == null || !hostHasPort) && Address.IsDefaultPort ?
				    uri.Host : uri.Host + ":" + uri.Port;
			}
			set {
				CheckRequestStarted ();

				if (value == null)
					throw new ArgumentNullException (nameof (value));

				Uri uri;
				if ((value.IndexOf ('/') != -1) || (!TryGetHostUri (value, out uri)))
					throw new ArgumentException (SR.net_invalid_host, nameof (value));

				hostUri = uri;

				// Determine if the user provided string contains a port
				if (!hostUri.IsDefaultPort) {
					hostHasPort = true;
				} else if (value.IndexOf (':') == -1) {
					hostHasPort = false;
				} else {
					int endOfIPv6Address = value.IndexOf (']');
					hostHasPort = endOfIPv6Address == -1 || value.LastIndexOf (':') > endOfIPv6Address;
				}
			}
		}

		bool TryGetHostUri (string hostName, out Uri hostUri)
		{
			string s = Address.Scheme + "://" + hostName + Address.PathAndQuery;
			return Uri.TryCreate (s, UriKind.Absolute, out hostUri);
		}

		public DateTime IfModifiedSince {
			get {
				string str = webHeaders["If-Modified-Since"];
				if (str == null)
					return DateTime.Now;
				try {
					return MonoHttpDate.Parse (str);
				} catch (Exception) {
					return DateTime.Now;
				}
			}
			set {
				CheckRequestStarted ();
				// rfc-1123 pattern
				webHeaders.SetInternal ("If-Modified-Since",
					value.ToUniversalTime ().ToString ("r", null));
				// TODO: check last param when using different locale
			}
		}

		public bool KeepAlive {
			get {
				return keepAlive;
			}
			set {
				keepAlive = value;
			}
		}

		public int MaximumAutomaticRedirections {
			get { return maxAutoRedirect; }
			set {
				if (value <= 0)
					throw new ArgumentException ("Must be > 0", "value");

				maxAutoRedirect = value;
			}
		}

		[MonoTODO ("Use this")]
		public int MaximumResponseHeadersLength {
			get { return maxResponseHeadersLength; }
			set {
				CheckRequestStarted ();
				if (value < 0 && value != System.Threading.Timeout.Infinite)
					throw new ArgumentOutOfRangeException (nameof (value), SR.net_toosmall);

				maxResponseHeadersLength = value;
			}
		}

		[MonoTODO ("Use this")]
		public static int DefaultMaximumResponseHeadersLength {
			get { return defaultMaxResponseHeadersLength; }
			set { defaultMaxResponseHeadersLength = value; }
		}

		public int ReadWriteTimeout {
			get { return readWriteTimeout; }
			set {
				CheckRequestStarted ();

				if (value <= 0 && value != System.Threading.Timeout.Infinite)
					throw new ArgumentOutOfRangeException (nameof (value), SR.net_io_timeout_use_gt_zero);

				readWriteTimeout = value;
			}
		}

		[MonoTODO]
		public int ContinueTimeout {
			get {
				return continueTimeout;
			}
			set {
				CheckRequestStarted ();
				if ((value < 0) && (value != System.Threading.Timeout.Infinite))
					throw new ArgumentOutOfRangeException (nameof (value), SR.net_io_timeout_use_ge_zero);
				continueTimeout = value;
			}
		}

		public string MediaType {
			get { return mediaType; }
			set {
				mediaType = value;
			}
		}

		public override string Method {
			get { return this.method; }
			set {
				if (string.IsNullOrEmpty (value))
					throw new ArgumentException (SR.net_badmethod, nameof (value));
				if (HttpValidationHelpers.IsInvalidMethodOrHeaderString (value))
					throw new ArgumentException (SR.net_badmethod, nameof (value));

				method = value.ToUpperInvariant ();
				if (method != "HEAD" && method != "GET" && method != "POST" && method != "PUT" &&
					method != "DELETE" && method != "CONNECT" && method != "TRACE" &&
					method != "MKCOL") {
					method = value;
				}
			}
		}

		public bool Pipelined {
			get { return pipelined; }
			set { pipelined = value; }
		}

		public override bool PreAuthenticate {
			get { return preAuthenticate; }
			set { preAuthenticate = value; }
		}

		public Version ProtocolVersion {
			get { return version; }
			set {
				if (value != HttpVersion.Version10 && value != HttpVersion.Version11)
					throw new ArgumentException (SR.net_wrongversion, nameof (value));

				force_version = true;
				version = value;
			}
		}

		public override IWebProxy Proxy {
			get { return proxy; }
			set {
				CheckRequestStarted ();
				proxy = value;
				servicePoint = null; // we may need a new one
				GetServicePoint ();
			}
		}

		public string Referer {
			get { return webHeaders["Referer"]; }
			set {
				CheckRequestStarted ();
				if (value == null || value.Trim ().Length == 0) {
					webHeaders.RemoveInternal ("Referer");
					return;
				}
				webHeaders.SetInternal ("Referer", value);
			}
		}

		public override Uri RequestUri {
			get { return requestUri; }
		}

		public bool SendChunked {
			get { return sendChunked; }
			set {
				CheckRequestStarted ();
				sendChunked = value;
			}
		}

		public ServicePoint ServicePoint {
			get { return GetServicePoint (); }
		}

		internal ServicePoint ServicePointNoLock {
			get { return servicePoint; }
		}
		public virtual bool SupportsCookieContainer {
			get {
				// The managed implementation supports the cookie container
				// it is only Silverlight that returns false here
				return true;
			}
		}
		public override int Timeout {
			get { return timeout; }
			set {
				if (value < -1)
					throw new ArgumentOutOfRangeException ("value");

				timeout = value;
			}
		}

		public string TransferEncoding {
			get { return webHeaders["Transfer-Encoding"]; }
			set {
				CheckRequestStarted ();

				if (string.IsNullOrWhiteSpace (value)) {
					webHeaders.RemoveInternal ("Transfer-Encoding");
					return;
				}

				string val = value.ToLower ();
				//
				// prevent them from adding chunked, or from adding an Encoding without
				// turning on chunked, the reason is due to the HTTP Spec which prevents
				// additional encoding types from being used without chunked
				//
				if (val.Contains ("chunked"))
					throw new ArgumentException (SR.net_nochunked, nameof (value));
				else if (!SendChunked)
					throw new InvalidOperationException (SR.net_needchunked);

				string checkedValue = HttpValidationHelpers.CheckBadHeaderValueChars (value);
				webHeaders.CheckUpdate ("Transfer-Encoding", checkedValue);
			}
		}

		public override bool UseDefaultCredentials {
			get { return CredentialCache.DefaultCredentials == Credentials; }
			set { Credentials = value ? CredentialCache.DefaultCredentials : null; }
		}

		public string UserAgent {
			get { return webHeaders["User-Agent"]; }
			set { webHeaders.SetInternal ("User-Agent", value); }
		}

		bool unsafe_auth_blah;
		public bool UnsafeAuthenticatedConnectionSharing {
			get { return unsafe_auth_blah; }
			set { unsafe_auth_blah = value; }
		}

		internal bool GotRequestStream {
			get { return gotRequestStream; }
		}

		internal bool ExpectContinue {
			get { return expectContinue; }
			set { expectContinue = value; }
		}

		internal Uri AuthUri {
			get { return actualUri; }
		}

		internal bool ProxyQuery {
			get { return servicePoint.UsesProxy && !servicePoint.UseConnect; }
		}

		internal ServerCertValidationCallback ServerCertValidationCallback {
			get { return certValidationCallback; }
		}

		public RemoteCertificateValidationCallback ServerCertificateValidationCallback {
			get {
				if (certValidationCallback == null)
					return null;
				return certValidationCallback.ValidationCallback;
			}
			set {
				if (value == null)
					certValidationCallback = null;
				else
					certValidationCallback = new ServerCertValidationCallback (value);
			}
		}

		// Methods

		internal ServicePoint GetServicePoint ()
		{
			lock (locker) {
				if (hostChanged || servicePoint == null) {
					servicePoint = ServicePointManager.FindServicePoint (actualUri, proxy);
					hostChanged = false;
				}
			}

			return servicePoint;
		}

		public void AddRange (int range)
		{
			AddRange ("bytes", (long)range);
		}

		public void AddRange (int from, int to)
		{
			AddRange ("bytes", (long)from, (long)to);
		}

		public void AddRange (string rangeSpecifier, int range)
		{
			AddRange (rangeSpecifier, (long)range);
		}

		public void AddRange (string rangeSpecifier, int from, int to)
		{
			AddRange (rangeSpecifier, (long)from, (long)to);
		}
		public
		void AddRange (long range)
		{
			AddRange ("bytes", (long)range);
		}

		public
		void AddRange (long from, long to)
		{
			AddRange ("bytes", from, to);
		}

		public
		void AddRange (string rangeSpecifier, long range)
		{
			if (rangeSpecifier == null)
				throw new ArgumentNullException ("rangeSpecifier");
			if (!WebHeaderCollection.IsValidToken (rangeSpecifier))
				throw new ArgumentException ("Invalid range specifier", "rangeSpecifier");

			string r = webHeaders["Range"];
			if (r == null)
				r = rangeSpecifier + "=";
			else {
				string old_specifier = r.Substring (0, r.IndexOf ('='));
				if (String.Compare (old_specifier, rangeSpecifier, StringComparison.OrdinalIgnoreCase) != 0)
					throw new InvalidOperationException ("A different range specifier is already in use");
				r += ",";
			}

			string n = range.ToString (CultureInfo.InvariantCulture);
			if (range < 0)
				r = r + "0" + n;
			else
				r = r + n + "-";
			webHeaders.ChangeInternal ("Range", r);
		}

		public
		void AddRange (string rangeSpecifier, long from, long to)
		{
			if (rangeSpecifier == null)
				throw new ArgumentNullException ("rangeSpecifier");
			if (!WebHeaderCollection.IsValidToken (rangeSpecifier))
				throw new ArgumentException ("Invalid range specifier", "rangeSpecifier");
			if (from > to || from < 0)
				throw new ArgumentOutOfRangeException ("from");
			if (to < 0)
				throw new ArgumentOutOfRangeException ("to");

			string r = webHeaders["Range"];
			if (r == null)
				r = rangeSpecifier + "=";
			else
				r += ",";

			r = String.Format ("{0}{1}-{2}", r, from, to);
			webHeaders.ChangeInternal ("Range", r);
		}

		WebOperation SendRequest (bool redirecting, BufferOffsetSize writeBuffer, CancellationToken cancellationToken)
		{
			lock (locker) {
				WebConnection.Debug ($"HWR SEND REQUEST: Req={ID} requestSent={requestSent} redirecting={redirecting}");

				WebOperation operation;
				if (!redirecting) {
					if (requestSent) {
						operation = currentOperation;
						if (operation == null)
							throw new InvalidOperationException ("Should never happen!");
						return operation;
					}
				}

				operation = new WebOperation (this, writeBuffer, false, cancellationToken);
				if (Interlocked.CompareExchange (ref currentOperation, operation, null) != null)
					throw new InvalidOperationException ("Invalid nested call.");

				requestSent = true;
				if (!redirecting)
					redirects = 0;
				servicePoint = GetServicePoint ();
				servicePoint.SendRequest (operation, connectionGroup);
				return operation;
			}
		}

		Task<Stream> MyGetRequestStreamAsync (CancellationToken cancellationToken)
		{
			if (Aborted)
				throw CreateRequestAbortedException ();

			bool send = !(method == "GET" || method == "CONNECT" || method == "HEAD" ||
					method == "TRACE");
			if (method == null || !send)
				throw new ProtocolViolationException ("Cannot send data when method is: " + method);

			if (contentLength == -1 && !sendChunked && !allowBuffering && KeepAlive)
				throw new ProtocolViolationException ("Content-Length not set");

			string transferEncoding = TransferEncoding;
			if (!sendChunked && transferEncoding != null && transferEncoding.Trim () != "")
				throw new ProtocolViolationException ("SendChunked should be true.");

			WebOperation operation;
			lock (locker) {
				if (getResponseCalled)
					throw new InvalidOperationException ("The operation cannot be performed once the request has been submitted.");

				operation = currentOperation;
				if (operation == null) {
					initialMethod = method;

					gotRequestStream = true;
					operation = SendRequest (false, null, cancellationToken);
				}
			}

			return operation.GetRequestStream ();
		}

		public override IAsyncResult BeginGetRequestStream (AsyncCallback callback, object state)
		{
			return TaskToApm.Begin (RunWithTimeout (MyGetRequestStreamAsync), callback, state);
		}

		public override Stream EndGetRequestStream (IAsyncResult asyncResult)
		{
			if (asyncResult == null)
				throw new ArgumentNullException ("asyncResult");

			try {
				return TaskToApm.End<Stream> (asyncResult);
			} catch (Exception e) {
				throw FlattenException (e);
			}
		}

		public override Stream GetRequestStream ()
		{
			try {
				return GetRequestStreamAsync ().Result;
			} catch (Exception e) {
				throw FlattenException (e);
			}
		}

		[MonoTODO]
		public Stream GetRequestStream (out TransportContext context)
		{
			throw new NotImplementedException ();
		}

		public override Task<Stream> GetRequestStreamAsync ()
		{
			return RunWithTimeout (MyGetRequestStreamAsync);
		}

		internal static Task<T> RunWithTimeout<T> (
			Func<CancellationToken, Task<T>> func, int timeout, Action abort)
		{
			// Call `func` here to propagate any potential exception that it
			// might throw to our caller rather than returning a faulted task.
			var cts = new CancellationTokenSource ();
			var workerTask = func (cts.Token);
			return RunWithTimeoutWorker (workerTask, timeout, abort, cts);
		}

		static async Task<T> RunWithTimeoutWorker<T> (
			Task<T> workerTask, int timeout, Action abort,
			CancellationTokenSource cts)
		{
			try {
				if (await ServicePointScheduler.WaitAsync (workerTask, timeout).ConfigureAwait (false))
					return workerTask.Result;
				try {
					cts.Cancel ();
					abort ();
				} catch {
					// Ignore; we report the timeout.
				}
				throw new WebException (SR.net_timeout, WebExceptionStatus.Timeout);
			} catch (Exception ex) {
				throw FlattenException (ex);
			} finally {
				cts.Dispose ();
			}
		}

		Task<T> RunWithTimeout<T> (Func<CancellationToken, Task<T>> func)
		{
			return RunWithTimeout (func, timeout, Abort);
		}

		async Task<HttpWebResponse> MyGetResponseAsync (CancellationToken cancellationToken)
		{
			if (Aborted)
				throw CreateRequestAbortedException ();

			if (method == null)
				throw new ProtocolViolationException ("Method is null.");

			string transferEncoding = TransferEncoding;
			if (!sendChunked && transferEncoding != null && transferEncoding.Trim () != "")
				throw new ProtocolViolationException ("SendChunked should be true.");

			var completion = new WebCompletionSource ();
			WebOperation operation;
			lock (locker) {
				getResponseCalled = true;
				var oldCompletion = Interlocked.CompareExchange (ref responseTask, completion, null);
				WebConnection.Debug ($"HWR GET RESPONSE: Req={ID} {oldCompletion != null}");
				if (oldCompletion != null) {
					oldCompletion.ThrowOnError ();
					if (haveResponse && oldCompletion.Task.IsCompleted)
						return webResponse;
					throw new InvalidOperationException ("Cannot re-call start of asynchronous " +
								"method while a previous call is still in progress.");
				}

				operation = currentOperation;
				if (currentOperation != null)
					writeStream = currentOperation.WriteStream;

				initialMethod = method;

				operation = SendRequest (false, null, cancellationToken);
			}

			while (true) {
				WebException throwMe = null;
				HttpWebResponse response = null;
				WebResponseStream stream = null;
				bool redirect = false;
				bool mustReadAll = false;
				WebOperation ntlm = null;
				BufferOffsetSize writeBuffer = null;

				try {
					cancellationToken.ThrowIfCancellationRequested ();

					WebConnection.Debug ($"HWR GET RESPONSE LOOP: Req={ID} {auth_state.NtlmAuthState}");

					writeStream = await operation.GetRequestStreamInternal ();
					await writeStream.WriteRequestAsync (cancellationToken).ConfigureAwait (false);

					stream = await operation.GetResponseStream ();

					WebConnection.Debug ($"HWR RESPONSE LOOP #0: Req={ID} - {stream?.Headers != null}");

					(response, redirect, mustReadAll, writeBuffer, ntlm) = await GetResponseFromData (
						stream, cancellationToken).ConfigureAwait (false);
				} catch (Exception e) {
					throwMe = GetWebException (e);
				}

				WebConnection.Debug ($"HWR GET RESPONSE LOOP #1: Req={ID} - redirect={redirect} mustReadAll={mustReadAll} writeBuffer={writeBuffer != null} ntlm={ntlm != null} - {throwMe != null}");

				lock (locker) {
					if (throwMe != null) {
						WebConnection.Debug ($"HWR GET RESPONSE LOOP #1 EX: Req={ID} {throwMe.Status} {throwMe.InnerException?.GetType ()}");
						haveResponse = true;
						completion.TrySetException (throwMe);
						throw throwMe;
					}

					if (!redirect) {
						haveResponse = true;
						webResponse = response;
						completion.TrySetCompleted ();
						return response;
					}

					finished_reading = false;
					haveResponse = false;
					webResponse = null;
					currentOperation = ntlm;
					WebConnection.Debug ($"HWR GET RESPONSE LOOP #2: Req={ID} {mustReadAll} {ntlm}");
				}

				try {
					if (mustReadAll)
						await stream.ReadAllAsync (redirect || ntlm != null, cancellationToken).ConfigureAwait (false);
					operation.Finish (true);
					response.Close ();
				} catch (Exception e) {
					throwMe = GetWebException (e);
				}

				lock (locker) {
					WebConnection.Debug ($"HWR GET RESPONSE LOOP #3: Req={ID} {writeBuffer != null} {ntlm != null}");
					if (throwMe != null) {
						WebConnection.Debug ($"HWR GET RESPONSE LOOP #3 EX: Req={ID} {throwMe.Status} {throwMe.InnerException?.GetType ()}");
						haveResponse = true;
						stream?.Close ();
						completion.TrySetException (throwMe);
						throw throwMe;
					}

					if (ntlm == null) {
						operation = SendRequest (true, writeBuffer, cancellationToken);
					} else {
						operation = ntlm;
					}
				}
			}
		}

		async Task<(HttpWebResponse response, bool redirect, bool mustReadAll, BufferOffsetSize writeBuffer, WebOperation ntlm)>
			GetResponseFromData (WebResponseStream stream, CancellationToken cancellationToken)
		{
			/*
			 * WebConnection has either called SetResponseData() or SetResponseError().
		 	*/

			var response = new HttpWebResponse (actualUri, method, stream, cookieContainer);

			WebException throwMe = null;
			bool redirect = false;
			bool mustReadAll = false;
			WebOperation ntlm = null;
			Task<BufferOffsetSize> rewriteHandler = null;
			BufferOffsetSize writeBuffer = null;

			lock (locker) {
				(redirect, mustReadAll, rewriteHandler, throwMe) = CheckFinalStatus (response);
			}

			if (throwMe != null) {
				if (mustReadAll)
					await stream.ReadAllAsync (false, cancellationToken).ConfigureAwait (false);
				throw throwMe;
			}

			if (rewriteHandler != null) {
				writeBuffer = await rewriteHandler.ConfigureAwait (false);
			}

			lock (locker) {
				bool isProxy = ProxyQuery && proxy != null && !proxy.IsBypassed (actualUri);

				if (!redirect) {
					if ((isProxy ? proxy_auth_state : auth_state).IsNtlmAuthenticated && (int)response.StatusCode < 400) {
						stream.Connection.NtlmAuthenticated = true;
					}

					// clear internal buffer so that it does not
					// hold possible big buffer (bug #397627)
					if (writeStream != null)
						writeStream.KillBuffer ();

					return (response, false, false, writeBuffer, null);
				}

				if (sendChunked) {
					sendChunked = false;
					webHeaders.RemoveInternal ("Transfer-Encoding");
				}

				bool isChallenge;
				(ntlm, isChallenge) = HandleNtlmAuth (stream, response, writeBuffer, cancellationToken);
				WebConnection.Debug ($"HWR REDIRECT: {ntlm} {isChallenge} {mustReadAll}");
			}

			return (response, true, mustReadAll, writeBuffer, ntlm);
		}

		internal static Exception FlattenException (Exception e)
		{
			if (e is AggregateException ae) {
				ae = ae.Flatten ();
				if (ae.InnerExceptions.Count == 1)
					return ae.InnerException;
			}

			return e;
		}

		WebException GetWebException (Exception e)
		{
			e = FlattenException (e);
			if (e is WebException wexc) {
				if (!Aborted || wexc.Status == WebExceptionStatus.RequestCanceled || wexc.Status == WebExceptionStatus.Timeout)
					return wexc;
			}
			if (Aborted || e is OperationCanceledException || e is ObjectDisposedException)
				return CreateRequestAbortedException ();
			return new WebException (e.Message, e, WebExceptionStatus.UnknownError, null);
		}

		internal static WebException CreateRequestAbortedException ()
		{
			return new WebException (SR.Format (SR.net_reqaborted, WebExceptionStatus.RequestCanceled), WebExceptionStatus.RequestCanceled);
		}

		public override IAsyncResult BeginGetResponse (AsyncCallback callback, object state)
		{
			if (Aborted)
				throw CreateRequestAbortedException ();

			return TaskToApm.Begin (RunWithTimeout (MyGetResponseAsync), callback, state);
		}

		public override WebResponse EndGetResponse (IAsyncResult asyncResult)
		{
			if (asyncResult == null)
				throw new ArgumentNullException (nameof (asyncResult));

			try {
				return TaskToApm.End<HttpWebResponse> (asyncResult);
			} catch (Exception e) {
				throw FlattenException (e);
			}
		}

		public Stream EndGetRequestStream (IAsyncResult asyncResult, out TransportContext context)
		{
			if (asyncResult == null)
				throw new ArgumentNullException (nameof (asyncResult));

			context = null;
			return EndGetRequestStream (asyncResult);
		}

		public override WebResponse GetResponse ()
		{
			try {
				return GetResponseAsync ().Result;
			} catch (Exception e) {
				throw FlattenException (e);
			}
		}

		internal bool FinishedReading {
			get { return finished_reading; }
			set { finished_reading = value; }
		}

		internal bool Aborted {
			get { return Interlocked.CompareExchange (ref aborted, 0, 0) == 1; }
		}

		public override void Abort ()
		{
			if (Interlocked.CompareExchange (ref aborted, 1, 0) == 1)
				return;

			WebConnection.Debug ($"HWR ABORT: Req={ID}");

			haveResponse = true;
			var operation = currentOperation;
			if (operation != null)
				operation.Abort ();

			responseTask?.TrySetCanceled ();

			if (webResponse != null) {
				try {
					webResponse.Close ();
					webResponse = null;
				} catch { }
			}
		}

		void ISerializable.GetObjectData (SerializationInfo serializationInfo,
		   				  StreamingContext streamingContext)
		{
			throw new SerializationException ();
		}

		protected override void GetObjectData (SerializationInfo serializationInfo,
			StreamingContext streamingContext)
		{
			throw new SerializationException ();
		}

		void CheckRequestStarted ()
		{
			if (requestSent)
				throw new InvalidOperationException ("request started");
		}

		internal void DoContinueDelegate (int statusCode, WebHeaderCollection headers)
		{
			if (continueDelegate != null)
				continueDelegate (statusCode, headers);
		}

		void RewriteRedirectToGet ()
		{
			method = "GET";
			webHeaders.RemoveInternal ("Transfer-Encoding");
			sendChunked = false;
		}

		bool Redirect (HttpStatusCode code, WebResponse response)
		{
			redirects++;
			Exception e = null;
			string uriString = null;
			switch (code) {
			case HttpStatusCode.Ambiguous: // 300
				e = new WebException ("Ambiguous redirect.");
				break;
			case HttpStatusCode.MovedPermanently: // 301
			case HttpStatusCode.Redirect: // 302
				if (method == "POST")
					RewriteRedirectToGet ();
				break;
			case HttpStatusCode.TemporaryRedirect: // 307
				break;
			case HttpStatusCode.SeeOther: //303
				RewriteRedirectToGet ();
				break;
			case HttpStatusCode.NotModified: // 304
				return false;
			case HttpStatusCode.UseProxy: // 305
				e = new NotImplementedException ("Proxy support not available.");
				break;
			case HttpStatusCode.Unused: // 306
			default:
				e = new ProtocolViolationException ("Invalid status code: " + (int)code);
				break;
			}

			if (method != "GET" && !InternalAllowBuffering && ResendContentFactory == null &&
			    (writeStream.WriteBufferLength > 0 || contentLength > 0))
				e = new WebException ("The request requires buffering data to succeed.", null, WebExceptionStatus.ProtocolError, response);

			if (e != null)
				throw e;

			if (AllowWriteStreamBuffering || method == "GET")
				contentLength = -1;

			uriString = response.Headers["Location"];

			if (uriString == null)
				throw new WebException ($"No Location header found for {(int)code}", null,
				                        WebExceptionStatus.ProtocolError, response);

			Uri prev = actualUri;
			try {
				actualUri = new Uri (actualUri, uriString);
			} catch (Exception) {
				throw new WebException ($"Invalid URL ({uriString}) for {(int)code}",
				                        null, WebExceptionStatus.ProtocolError, response);
			}

			hostChanged = (actualUri.Scheme != prev.Scheme || Host != prev.Authority);
			return true;
		}

		string GetHeaders ()
		{
			bool continue100 = false;
			if (sendChunked) {
				continue100 = true;
				webHeaders.ChangeInternal ("Transfer-Encoding", "chunked");
				webHeaders.RemoveInternal ("Content-Length");
			} else if (contentLength != -1) {
				if (auth_state.NtlmAuthState == NtlmAuthState.Challenge || proxy_auth_state.NtlmAuthState == NtlmAuthState.Challenge) {
					// We don't send any body with the NTLM Challenge request.
					if (haveContentLength || gotRequestStream || contentLength > 0)
						webHeaders.SetInternal ("Content-Length", "0");
					else
						webHeaders.RemoveInternal ("Content-Length");
				} else {
					if (contentLength > 0)
						continue100 = true;

					if (haveContentLength || gotRequestStream || contentLength > 0)
						webHeaders.SetInternal ("Content-Length", contentLength.ToString ());
				}
				webHeaders.RemoveInternal ("Transfer-Encoding");
			} else {
				webHeaders.RemoveInternal ("Content-Length");
			}

			if (actualVersion == HttpVersion.Version11 && continue100 &&
			    servicePoint.SendContinue) { // RFC2616 8.2.3
				webHeaders.ChangeInternal ("Expect", "100-continue");
				expectContinue = true;
			} else {
				webHeaders.RemoveInternal ("Expect");
				expectContinue = false;
			}

			bool proxy_query = ProxyQuery;
			string connectionHeader = (proxy_query) ? "Proxy-Connection" : "Connection";
			webHeaders.RemoveInternal ((!proxy_query) ? "Proxy-Connection" : "Connection");
			Version proto_version = servicePoint.ProtocolVersion;
			bool spoint10 = (proto_version == null || proto_version == HttpVersion.Version10);

			if (keepAlive && (version == HttpVersion.Version10 || spoint10)) {
				if (webHeaders[connectionHeader] == null
				    || webHeaders[connectionHeader].IndexOf ("keep-alive", StringComparison.OrdinalIgnoreCase) == -1)
					webHeaders.ChangeInternal (connectionHeader, "keep-alive");
			} else if (!keepAlive && version == HttpVersion.Version11) {
				webHeaders.ChangeInternal (connectionHeader, "close");
			}

			string host;
			if (hostUri != null) {
				if (hostHasPort)
					host = hostUri.GetComponents (UriComponents.HostAndPort, UriFormat.Unescaped);
				else
					host = hostUri.GetComponents (UriComponents.Host, UriFormat.Unescaped);
			} else if (Address.IsDefaultPort) {
				host = Address.GetComponents (UriComponents.Host, UriFormat.Unescaped);
			} else {
				host = Address.GetComponents (UriComponents.HostAndPort, UriFormat.Unescaped);
			}
			webHeaders.SetInternal ("Host", host);

			if (cookieContainer != null) {
				string cookieHeader = cookieContainer.GetCookieHeader (actualUri);
				if (cookieHeader != "")
					webHeaders.ChangeInternal ("Cookie", cookieHeader);
				else
					webHeaders.RemoveInternal ("Cookie");
			}

			string accept_encoding = null;
			if ((auto_decomp & DecompressionMethods.GZip) != 0)
				accept_encoding = "gzip";
			if ((auto_decomp & DecompressionMethods.Deflate) != 0)
				accept_encoding = accept_encoding != null ? "gzip, deflate" : "deflate";
			if (accept_encoding != null)
				webHeaders.ChangeInternal ("Accept-Encoding", accept_encoding);

			if (!usedPreAuth && preAuthenticate)
				DoPreAuthenticate ();

			return webHeaders.ToString ();
		}

		void DoPreAuthenticate ()
		{
			bool isProxy = (proxy != null && !proxy.IsBypassed (actualUri));
			ICredentials creds = (!isProxy || credentials != null) ? credentials : proxy.Credentials;
			Authorization auth = AuthenticationManager.PreAuthenticate (this, creds);
			if (auth == null)
				return;

			webHeaders.RemoveInternal ("Proxy-Authorization");
			webHeaders.RemoveInternal ("Authorization");
			string authHeader = (isProxy && credentials == null) ? "Proxy-Authorization" : "Authorization";
			webHeaders[authHeader] = auth.Message;
			usedPreAuth = true;
		}

		internal byte[] GetRequestHeaders ()
		{
			StringBuilder req = new StringBuilder ();
			string query;
			if (!ProxyQuery) {
				query = actualUri.PathAndQuery;
			} else {
				query = String.Format ("{0}://{1}{2}", actualUri.Scheme,
									Host,
									actualUri.PathAndQuery);
			}

			if (!force_version && servicePoint.ProtocolVersion != null && servicePoint.ProtocolVersion < version) {
				actualVersion = servicePoint.ProtocolVersion;
			} else {
				actualVersion = version;
			}

			req.AppendFormat ("{0} {1} HTTP/{2}.{3}\r\n", method, query,
								actualVersion.Major, actualVersion.Minor);
			req.Append (GetHeaders ());
			string reqstr = req.ToString ();
			return Encoding.UTF8.GetBytes (reqstr);
		}

		(WebOperation, bool) HandleNtlmAuth (WebResponseStream stream, HttpWebResponse response,
						     BufferOffsetSize writeBuffer, CancellationToken cancellationToken)
		{
			bool isProxy = response.StatusCode == HttpStatusCode.ProxyAuthenticationRequired;
			if ((isProxy ? proxy_auth_state : auth_state).NtlmAuthState == NtlmAuthState.None)
				return (null, false);

			var isChallenge = auth_state.NtlmAuthState == NtlmAuthState.Challenge || proxy_auth_state.NtlmAuthState == NtlmAuthState.Challenge;

			var operation = new WebOperation (this, writeBuffer, isChallenge, cancellationToken);
			stream.Operation.SetPriorityRequest (operation);
			var creds = (!isProxy || proxy == null) ? credentials : proxy.Credentials;
			if (creds != null) {
				stream.Connection.NtlmCredential = creds.GetCredential (requestUri, "NTLM");
				stream.Connection.UnsafeAuthenticatedConnectionSharing = unsafe_auth_blah;
			}
			return (operation, isChallenge);
		}

		struct AuthorizationState
		{
			readonly HttpWebRequest request;
			readonly bool isProxy;
			bool isCompleted;
			NtlmAuthState ntlm_auth_state;

			public bool IsCompleted {
				get { return isCompleted; }
			}

			public NtlmAuthState NtlmAuthState {
				get { return ntlm_auth_state; }
			}

			public bool IsNtlmAuthenticated {
				get { return isCompleted && ntlm_auth_state != NtlmAuthState.None; }
			}

			public AuthorizationState (HttpWebRequest request, bool isProxy)
			{
				this.request = request;
				this.isProxy = isProxy;
				isCompleted = false;
				ntlm_auth_state = NtlmAuthState.None;
			}

			public bool CheckAuthorization (WebResponse response, HttpStatusCode code)
			{
				isCompleted = false;
				if (code == HttpStatusCode.Unauthorized && request.credentials == null)
					return false;

				// FIXME: This should never happen!
				if (isProxy != (code == HttpStatusCode.ProxyAuthenticationRequired))
					return false;

				if (isProxy && (request.proxy == null || request.proxy.Credentials == null))
					return false;

				string[] authHeaders = response.Headers.GetValues (isProxy ? "Proxy-Authenticate" : "WWW-Authenticate");
				if (authHeaders == null || authHeaders.Length == 0)
					return false;

				ICredentials creds = (!isProxy) ? request.credentials : request.proxy.Credentials;
				Authorization auth = null;
				foreach (string authHeader in authHeaders) {
					auth = AuthenticationManager.Authenticate (authHeader, request, creds);
					if (auth != null)
						break;
				}
				if (auth == null)
					return false;
				request.webHeaders[isProxy ? "Proxy-Authorization" : "Authorization"] = auth.Message;
				isCompleted = auth.Complete;
				bool is_ntlm = (auth.ModuleAuthenticationType == "NTLM");
				if (is_ntlm)
					ntlm_auth_state = (NtlmAuthState)((int)ntlm_auth_state + 1);
				return true;
			}

			public void Reset ()
			{
				isCompleted = false;
				ntlm_auth_state = NtlmAuthState.None;
				request.webHeaders.RemoveInternal (isProxy ? "Proxy-Authorization" : "Authorization");
			}

			public override string ToString ()
			{
				return string.Format ("{0}AuthState [{1}:{2}]", isProxy ? "Proxy" : "", isCompleted, ntlm_auth_state);
			}
		}

		bool CheckAuthorization (WebResponse response, HttpStatusCode code)
		{
			bool isProxy = code == HttpStatusCode.ProxyAuthenticationRequired;
			return isProxy ? proxy_auth_state.CheckAuthorization (response, code) : auth_state.CheckAuthorization (response, code);
		}

		(Task<BufferOffsetSize> task, WebException throwMe) GetRewriteHandler (HttpWebResponse response, bool redirect)
		{
			if (redirect) {
				if (!MethodWithBuffer)
					return (null, null);

				if (writeStream.WriteBufferLength == 0 || contentLength == 0)
					return (null, null);
			}

			// Keep the written body, so it can be rewritten in the retry
			if (AllowWriteStreamBuffering)
				return (Task.FromResult (writeStream.GetWriteBuffer ()), null);

			if (ResendContentFactory == null)
				return (null, new WebException (
					"The request requires buffering data to succeed.", null, WebExceptionStatus.ProtocolError, response));

			Func<Task<BufferOffsetSize>> handleResendContentFactory = async () => {
				using (var ms = new MemoryStream ()) {
					await ResendContentFactory (ms).ConfigureAwait (false);
					var buffer = ms.ToArray ();
					return new BufferOffsetSize (buffer, 0, buffer.Length, false);
				}
			};

			//
			// Buffering is not allowed but we have alternative way to get same content (we
			// need to resent it due to NTLM Authentication).
			//
			return (handleResendContentFactory (), null);
		}

		// Returns true if redirected
		(bool redirect, bool mustReadAll, Task<BufferOffsetSize> writeBuffer, WebException throwMe) CheckFinalStatus (HttpWebResponse response)
		{
			WebException throwMe = null;

			bool mustReadAll = false;
			HttpStatusCode code = 0;
			Task<BufferOffsetSize> rewriteHandler = null;

			code = response.StatusCode;
			if ((!auth_state.IsCompleted && code == HttpStatusCode.Unauthorized && credentials != null) ||
				(ProxyQuery && !proxy_auth_state.IsCompleted && code == HttpStatusCode.ProxyAuthenticationRequired)) {
				if (!usedPreAuth && CheckAuthorization (response, code)) {
					mustReadAll = true;

					// HEAD, GET, MKCOL, CONNECT, TRACE
					if (!MethodWithBuffer)
						return (true, mustReadAll, null, null);

					(rewriteHandler, throwMe) = GetRewriteHandler (response, false);
					if (throwMe == null)
						return (true, mustReadAll, rewriteHandler, null);

					if (!ThrowOnError)
						return (false, mustReadAll, null, null);

					writeStream.InternalClose ();
					writeStream = null;
					response.Close ();

					return (false, mustReadAll, null, throwMe);
				}
			}

			if ((int)code >= 400) {
				string err = String.Format ("The remote server returned an error: ({0}) {1}.",
				                            (int)code, response.StatusDescription);
				throwMe = new WebException (err, null, WebExceptionStatus.ProtocolError, response);
				mustReadAll = true;
			} else if ((int)code == 304 && allowAutoRedirect) {
				string err = String.Format ("The remote server returned an error: ({0}) {1}.",
				                            (int)code, response.StatusDescription);
				throwMe = new WebException (err, null, WebExceptionStatus.ProtocolError, response);
			} else if ((int)code >= 300 && allowAutoRedirect && redirects >= maxAutoRedirect) {
				throwMe = new WebException ("Max. redirections exceeded.", null,
				                            WebExceptionStatus.ProtocolError, response);
				mustReadAll = true;
			}

			if (throwMe == null) {
				int c = (int)code;
				bool b = false;
				if (allowAutoRedirect && c >= 300) {
					b = Redirect (code, response);
					(rewriteHandler, throwMe) = GetRewriteHandler (response, true);
					if (b && !unsafe_auth_blah) {
						auth_state.Reset ();
						proxy_auth_state.Reset ();
					}
				}

				if (c >= 300 && c != 304)
					mustReadAll = true;

				if (throwMe == null)
					return (b, mustReadAll, rewriteHandler, null);
			}

			if (!ThrowOnError)
				return (false, mustReadAll, null, null);

			if (writeStream != null) {
				writeStream.InternalClose ();
				writeStream = null;
			}

			return (false, mustReadAll, null, throwMe);
		}

		internal bool ReuseConnection {
			get;
			set;
		}

#region referencesource
        internal static StringBuilder GenerateConnectionGroup(string connectionGroupName, bool unsafeConnectionGroup, bool isInternalGroup)
        {
            StringBuilder connectionLine = new StringBuilder(connectionGroupName);

            connectionLine.Append(unsafeConnectionGroup ? "U>" : "S>");

            if (isInternalGroup)
            {
                connectionLine.Append("I>");
            }

            return connectionLine;
        }
#endregion
	}
}