Handle nt auth with Connection: close on initial challenge (#31527)

geoffkizer · davidsh · commit eedddac1bd10 · 2018-08-03T10:55:11.000-07:00
When we receive an initial NT auth challenge that has Connection: close set on the response, we need to proceed with authentication on a new connection.

Fixes #30327
diff --git a/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/AuthenticationHelper.NtAuth.cs b/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/AuthenticationHelper.NtAuth.cs
@@ -3,6 +3,7 @@
 // See the LICENSE file in the project root for more information.
 
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Net.Http.Headers;
 using System.Threading;
 using System.Threading.Tasks;
@@ -12,11 +13,11 @@ namespace System.Net.Http
 {
     internal partial class AuthenticationHelper
     {
-        private static Task<HttpResponseMessage> InnerSendAsync(HttpRequestMessage request, bool isProxyAuth, HttpConnection connection, CancellationToken cancellationToken)
+        private static Task<HttpResponseMessage> InnerSendAsync(HttpRequestMessage request, bool isProxyAuth, HttpConnectionPool pool, HttpConnection connection, CancellationToken cancellationToken)
         {
             return isProxyAuth ?
                 connection.SendAsyncCore(request, cancellationToken) :
-                connection.SendWithNtProxyAuthAsync(request, cancellationToken);
+                pool.SendWithNtProxyAuthAsync(connection, request, cancellationToken);
         }
 
         private static bool ProxySupportsConnectionAuth(HttpResponseMessage response)
@@ -37,9 +38,9 @@ private static bool ProxySupportsConnectionAuth(HttpResponseMessage response)
             return false;
         }
 
-        private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMessage request, Uri authUri, ICredentials credentials, bool isProxyAuth, HttpConnection connection, CancellationToken cancellationToken)
+        private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMessage request, Uri authUri, ICredentials credentials, bool isProxyAuth, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken)
         {
-            HttpResponseMessage response = await InnerSendAsync(request, isProxyAuth, connection, cancellationToken).ConfigureAwait(false);
+            HttpResponseMessage response = await InnerSendAsync(request, isProxyAuth, connectionPool, connection, cancellationToken).ConfigureAwait(false);
             if (!isProxyAuth && connection.Kind == HttpConnectionKind.Proxy && !ProxySupportsConnectionAuth(response))
             {
                 // Proxy didn't indicate that it supports connection-based auth, so we can't proceed.
@@ -55,51 +56,80 @@ private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMe
                 if (challenge.AuthenticationType == AuthenticationType.Negotiate || 
                     challenge.AuthenticationType == AuthenticationType.Ntlm)
                 {
-                    string challengeData = challenge.ChallengeData;
-
-                    string spn = "HTTP/" + authUri.IdnHost;
-                    ChannelBinding channelBinding = connection.TransportContext?.GetChannelBinding(ChannelBindingKind.Endpoint);
-                    NTAuthentication authContext = new NTAuthentication(isServer:false, challenge.SchemeName, challenge.Credential, spn, ContextFlagsPal.Connection, channelBinding);
+                    bool isNewConnection = false;
                     try
                     {
-                        while (true)
+                        if (response.Headers.ConnectionClose.GetValueOrDefault())
                         {
-                            string challengeResponse = authContext.GetOutgoingBlob(challengeData);
-                            if (challengeResponse == null)
+                            // Server is closing the connection and asking us to authenticate on a new connection.
+                            (connection, response) = await connectionPool.CreateHttp11ConnectionAsync(request, cancellationToken).ConfigureAwait(false);
+                            if (response != null)
                             {
-                                // Response indicated denial even after login, so stop processing and return current response.
-                                break;
+                                return response;
                             }
 
+                            connectionPool.IncrementConnectionCount();
+                            connection.Acquire();
+                            isNewConnection = true;
+                        }
+                        else
+                        {
                             await connection.DrainResponseAsync(response).ConfigureAwait(false);
+                        }
 
-                            SetRequestAuthenticationHeaderValue(request, new AuthenticationHeaderValue(challenge.SchemeName, challengeResponse), isProxyAuth);
+                        string challengeData = challenge.ChallengeData;
 
-                            response = await InnerSendAsync(request, isProxyAuth, connection, cancellationToken).ConfigureAwait(false);
-                            if (authContext.IsCompleted || !TryGetRepeatedChallenge(response, challenge.SchemeName, isProxyAuth, out challengeData))
+                        string spn = "HTTP/" + authUri.IdnHost;
+                        ChannelBinding channelBinding = connection.TransportContext?.GetChannelBinding(ChannelBindingKind.Endpoint);
+                        NTAuthentication authContext = new NTAuthentication(isServer:false, challenge.SchemeName, challenge.Credential, spn, ContextFlagsPal.Connection, channelBinding);
+                        try
+                        {
+                            while (true)
                             {
-                                break;
+                                string challengeResponse = authContext.GetOutgoingBlob(challengeData);
+                                if (challengeResponse == null)
+                                {
+                                    // Response indicated denial even after login, so stop processing and return current response.
+                                    break;
+                                }
+
+                                SetRequestAuthenticationHeaderValue(request, new AuthenticationHeaderValue(challenge.SchemeName, challengeResponse), isProxyAuth);
+
+                                response = await InnerSendAsync(request, isProxyAuth, connectionPool, connection, cancellationToken).ConfigureAwait(false);
+                                if (authContext.IsCompleted || !TryGetRepeatedChallenge(response, challenge.SchemeName, isProxyAuth, out challengeData))
+                                {
+                                    break;
+                                }
+
+                                await connection.DrainResponseAsync(response).ConfigureAwait(false);
                             }
                         }
+                        finally
+                        {
+                            authContext.CloseContext();
+                        }
                     }
                     finally
                     {
-                        authContext.CloseContext();
+                        if (isNewConnection)
+                        {
+                            connection.Release();
+                        }
                     }
                 }
             }
 
             return response;
         }
 
-        public static Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpRequestMessage request, Uri proxyUri, ICredentials proxyCredentials, HttpConnection connection, CancellationToken cancellationToken)
+        public static Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpRequestMessage request, Uri proxyUri, ICredentials proxyCredentials, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken)
         {
-            return SendWithNtAuthAsync(request, proxyUri, proxyCredentials, isProxyAuth:true, connection, cancellationToken);
+            return SendWithNtAuthAsync(request, proxyUri, proxyCredentials, isProxyAuth:true, connection, connectionPool, cancellationToken);
         }
 
-        public static Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpRequestMessage request, ICredentials credentials, HttpConnection connection, CancellationToken cancellationToken)
+        public static Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpRequestMessage request, ICredentials credentials, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken)
         {
-            return SendWithNtAuthAsync(request, request.RequestUri, credentials, isProxyAuth:false, connection, cancellationToken);
+            return SendWithNtAuthAsync(request, request.RequestUri, credentials, isProxyAuth:false, connection, connectionPool, cancellationToken);
         }
     }
 }
diff --git a/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs b/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs
@@ -673,7 +673,7 @@ private async Task SendFramesAsync(Memory<byte> frame)
 
         // Note that this is safe to be called concurrently by multiple threads.
 
-        public sealed override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken)
+        public sealed override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
             Http2Stream http2Stream = new Http2Stream(this);
             try
diff --git a/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs b/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs
@@ -682,39 +682,11 @@ public async Task<HttpResponseMessage> SendAsyncCore(HttpRequestMessage request,
             }
         }
 
-        public Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        public sealed override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
-            if (_pool.AnyProxyKind && _pool.ProxyCredentials != null)
-            {
-                return AuthenticationHelper.SendWithNtProxyAuthAsync(request, _pool.ProxyUri, _pool.ProxyCredentials, this, cancellationToken);
-            }
-
             return SendAsyncCore(request, cancellationToken);
         }
 
-        private Task<HttpResponseMessage> SendAsyncInternal(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken)
-        {
-            if (doRequestAuth && _pool.Settings._credentials != null)
-            {
-                return AuthenticationHelper.SendWithNtConnectionAuthAsync(request, _pool.Settings._credentials, this, cancellationToken);
-            }
-
-            return SendWithNtProxyAuthAsync(request, cancellationToken);
-        }
-
-        public sealed override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken)
-        {
-            Acquire();
-            try
-            {
-                return await SendAsyncInternal(request, doRequestAuth, cancellationToken).ConfigureAwait(false);
-            }
-            finally
-            {
-                Release();
-            }
-        }
-
         private HttpContentWriteStream CreateRequestContentStream(HttpRequestMessage request)
         {
             bool requestTransferEncodingChunked = request.HasHeaders && request.Headers.TransferEncodingChunked == true;
@@ -1471,15 +1443,15 @@ private async Task CopyToExactLengthAsync(Stream destination, ulong length, Canc
             }
         }
 
-        private void Acquire()
+        internal void Acquire()
         {
             Debug.Assert(_currentRequest == null);
             Debug.Assert(!_inUse);
 
             _inUse = true;
         }
 
-        private void Release()
+        internal void Release()
         {
             Debug.Assert(_inUse);
 
diff --git a/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionBase.cs b/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionBase.cs
@@ -9,6 +9,6 @@ namespace System.Net.Http
 {
     internal abstract class HttpConnectionBase
     {
-        public abstract Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken);
+        public abstract Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);
     }
 }
diff --git a/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs b/src/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs
@@ -464,7 +464,14 @@ public async Task<HttpResponseMessage> SendWithRetryAsync(HttpRequestMessage req
 
                 try
                 {
-                    return await connection.SendAsync(request, doRequestAuth, cancellationToken).ConfigureAwait(false);
+                    if (connection is HttpConnection)
+                    {
+                        return await SendWithNtConnectionAuthAsync((HttpConnection)connection, request, doRequestAuth, cancellationToken).ConfigureAwait(false);
+                    }
+                    else
+                    {
+                        return await connection.SendAsync(request, cancellationToken).ConfigureAwait(false);
+                    }
                 }
                 catch (HttpRequestException e) when (!isNewConnection && e.AllowRetry)
                 {
@@ -478,6 +485,35 @@ public async Task<HttpResponseMessage> SendWithRetryAsync(HttpRequestMessage req
             }
         }
 
+        public async Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpConnection connection, HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken)
+        {
+            connection.Acquire();
+            try
+            {
+                if (doRequestAuth && Settings._credentials != null)
+                {
+                    return await AuthenticationHelper.SendWithNtConnectionAuthAsync(request, Settings._credentials, connection, this, cancellationToken).ConfigureAwait(false);
+                }
+
+                return await SendWithNtProxyAuthAsync(connection, request, cancellationToken).ConfigureAwait(false);
+            }
+            finally
+            {
+                connection.Release();
+            }
+        }
+
+        public Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpConnection connection, HttpRequestMessage request, CancellationToken cancellationToken)
+        {
+            if (AnyProxyKind && ProxyCredentials != null)
+            {
+                return AuthenticationHelper.SendWithNtProxyAuthAsync(request, ProxyUri, ProxyCredentials, connection, this, cancellationToken);
+            }
+
+            return connection.SendAsync(request, cancellationToken);
+        }
+
+
         public Task<HttpResponseMessage> SendWithProxyAuthAsync(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken)
         {
             if ((_kind == HttpConnectionKind.Proxy || _kind == HttpConnectionKind.ProxyConnect) &&
@@ -556,7 +592,7 @@ public Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool doRe
             }
         }
 
-        private async ValueTask<(HttpConnection, HttpResponseMessage)> CreateHttp11ConnectionAsync(HttpRequestMessage request, CancellationToken cancellationToken)
+        internal async ValueTask<(HttpConnection, HttpResponseMessage)> CreateHttp11ConnectionAsync(HttpRequestMessage request, CancellationToken cancellationToken)
         {
             (Socket socket, Stream stream, TransportContext transportContext, HttpResponseMessage failureResponse) =
                 await ConnectAsync(request, false, cancellationToken).ConfigureAwait(false);
@@ -706,6 +742,15 @@ private void IncrementConnectionCountNoLock()
             _associatedConnectionCount++;
         }
 
+        internal void IncrementConnectionCount()
+        {
+            lock (SyncObj)
+            {
+                IncrementConnectionCountNoLock();
+            }
+        }
+
+
         /// <summary>
         /// Decrements the number of connections associated with the pool.
         /// If there are waiters on the pool due to having reached the maximum,

Original file line number	Diff line number	Diff line change
`@@ -3,6 +3,7 @@`
`3`	`3`	`// See the LICENSE file in the project root for more information.`
`4`	`4`
`5`	`5`	`using System.Collections.Generic;`
	`6`	`+using System.Diagnostics;`
`6`	`7`	`using System.Net.Http.Headers;`
`7`	`8`	`using System.Threading;`
`8`	`9`	`using System.Threading.Tasks;`
`@@ -12,11 +13,11 @@ namespace System.Net.Http`
`12`	`13`	`{`
`13`	`14`	`internal partial class AuthenticationHelper`
`14`	`15`	`{`
`15`		`- private static Task<HttpResponseMessage> InnerSendAsync(HttpRequestMessage request, bool isProxyAuth, HttpConnection connection, CancellationToken cancellationToken)`
	`16`	`+ private static Task<HttpResponseMessage> InnerSendAsync(HttpRequestMessage request, bool isProxyAuth, HttpConnectionPool pool, HttpConnection connection, CancellationToken cancellationToken)`
`16`	`17`	`{`
`17`	`18`	`return isProxyAuth ?`
`18`	`19`	`connection.SendAsyncCore(request, cancellationToken) :`
`19`		`- connection.SendWithNtProxyAuthAsync(request, cancellationToken);`
	`20`	`+ pool.SendWithNtProxyAuthAsync(connection, request, cancellationToken);`
`20`	`21`	`}`
`21`	`22`
`22`	`23`	`private static bool ProxySupportsConnectionAuth(HttpResponseMessage response)`
`@@ -37,9 +38,9 @@ private static bool ProxySupportsConnectionAuth(HttpResponseMessage response)`
`37`	`38`	`return false;`
`38`	`39`	`}`
`39`	`40`
`40`		`- private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMessage request, Uri authUri, ICredentials credentials, bool isProxyAuth, HttpConnection connection, CancellationToken cancellationToken)`
	`41`	`+ private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMessage request, Uri authUri, ICredentials credentials, bool isProxyAuth, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken)`
`41`	`42`	`{`
`42`		`- HttpResponseMessage response = await InnerSendAsync(request, isProxyAuth, connection, cancellationToken).ConfigureAwait(false);`
	`43`	`+ HttpResponseMessage response = await InnerSendAsync(request, isProxyAuth, connectionPool, connection, cancellationToken).ConfigureAwait(false);`
`43`	`44`	`if (!isProxyAuth && connection.Kind == HttpConnectionKind.Proxy && !ProxySupportsConnectionAuth(response))`
`44`	`45`	`{`
`45`	`46`	`// Proxy didn't indicate that it supports connection-based auth, so we can't proceed.`
`@@ -55,51 +56,80 @@ private static async Task<HttpResponseMessage> SendWithNtAuthAsync(HttpRequestMe`
`55`	`56`	`if (challenge.AuthenticationType == AuthenticationType.Negotiate \|\|`
`56`	`57`	`challenge.AuthenticationType == AuthenticationType.Ntlm)`
`57`	`58`	`{`
`58`		`- string challengeData = challenge.ChallengeData;`
`59`		`-`
`60`		`- string spn = "HTTP/" + authUri.IdnHost;`
`61`		`- ChannelBinding channelBinding = connection.TransportContext?.GetChannelBinding(ChannelBindingKind.Endpoint);`
`62`		`- NTAuthentication authContext = new NTAuthentication(isServer:false, challenge.SchemeName, challenge.Credential, spn, ContextFlagsPal.Connection, channelBinding);`
	`59`	`+ bool isNewConnection = false;`
`63`	`60`	`try`
`64`	`61`	`{`
`65`		`- while (true)`
	`62`	`+ if (response.Headers.ConnectionClose.GetValueOrDefault())`
`66`	`63`	`{`
`67`		`- string challengeResponse = authContext.GetOutgoingBlob(challengeData);`
`68`		`- if (challengeResponse == null)`
	`64`	`+ // Server is closing the connection and asking us to authenticate on a new connection.`
	`65`	`+ (connection, response) = await connectionPool.CreateHttp11ConnectionAsync(request, cancellationToken).ConfigureAwait(false);`
	`66`	`+ if (response != null)`
`69`	`67`	`{`
`70`		`- // Response indicated denial even after login, so stop processing and return current response.`
`71`		`- break;`
	`68`	`+ return response;`
`72`	`69`	`}`
`73`	`70`
	`71`	`+ connectionPool.IncrementConnectionCount();`
	`72`	`+ connection.Acquire();`
	`73`	`+ isNewConnection = true;`
	`74`	`+ }`
	`75`	`+ else`
	`76`	`+ {`
`74`	`77`	`await connection.DrainResponseAsync(response).ConfigureAwait(false);`
	`78`	`+ }`
`75`	`79`
`76`		`- SetRequestAuthenticationHeaderValue(request, new AuthenticationHeaderValue(challenge.SchemeName, challengeResponse), isProxyAuth);`
	`80`	`+ string challengeData = challenge.ChallengeData;`
`77`	`81`
`78`		`- response = await InnerSendAsync(request, isProxyAuth, connection, cancellationToken).ConfigureAwait(false);`
`79`		`- if (authContext.IsCompleted \|\| !TryGetRepeatedChallenge(response, challenge.SchemeName, isProxyAuth, out challengeData))`
	`82`	`+ string spn = "HTTP/" + authUri.IdnHost;`
	`83`	`+ ChannelBinding channelBinding = connection.TransportContext?.GetChannelBinding(ChannelBindingKind.Endpoint);`
	`84`	`+ NTAuthentication authContext = new NTAuthentication(isServer:false, challenge.SchemeName, challenge.Credential, spn, ContextFlagsPal.Connection, channelBinding);`
	`85`	`+ try`
	`86`	`+ {`
	`87`	`+ while (true)`
`80`	`88`	`{`
`81`		`- break;`
	`89`	`+ string challengeResponse = authContext.GetOutgoingBlob(challengeData);`
	`90`	`+ if (challengeResponse == null)`
	`91`	`+ {`
	`92`	`+ // Response indicated denial even after login, so stop processing and return current response.`
	`93`	`+ break;`
	`94`	`+ }`
	`95`	`+`
	`96`	`+ SetRequestAuthenticationHeaderValue(request, new AuthenticationHeaderValue(challenge.SchemeName, challengeResponse), isProxyAuth);`
	`97`	`+`
	`98`	`+ response = await InnerSendAsync(request, isProxyAuth, connectionPool, connection, cancellationToken).ConfigureAwait(false);`
	`99`	`+ if (authContext.IsCompleted \|\| !TryGetRepeatedChallenge(response, challenge.SchemeName, isProxyAuth, out challengeData))`
	`100`	`+ {`
	`101`	`+ break;`
	`102`	`+ }`
	`103`	`+`
	`104`	`+ await connection.DrainResponseAsync(response).ConfigureAwait(false);`
`82`	`105`	`}`
`83`	`106`	`}`
	`107`	`+ finally`
	`108`	`+ {`
	`109`	`+ authContext.CloseContext();`
	`110`	`+ }`
`84`	`111`	`}`
`85`	`112`	`finally`
`86`	`113`	`{`
`87`		`- authContext.CloseContext();`
	`114`	`+ if (isNewConnection)`
	`115`	`+ {`
	`116`	`+ connection.Release();`
	`117`	`+ }`
`88`	`118`	`}`
`89`	`119`	`}`
`90`	`120`	`}`
`91`	`121`
`92`	`122`	`return response;`
`93`	`123`	`}`
`94`	`124`
`95`		`- public static Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpRequestMessage request, Uri proxyUri, ICredentials proxyCredentials, HttpConnection connection, CancellationToken cancellationToken)`
	`125`	`+ public static Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpRequestMessage request, Uri proxyUri, ICredentials proxyCredentials, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken)`
`96`	`126`	`{`
`97`		`- return SendWithNtAuthAsync(request, proxyUri, proxyCredentials, isProxyAuth:true, connection, cancellationToken);`
	`127`	`+ return SendWithNtAuthAsync(request, proxyUri, proxyCredentials, isProxyAuth:true, connection, connectionPool, cancellationToken);`
`98`	`128`	`}`
`99`	`129`
`100`		`- public static Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpRequestMessage request, ICredentials credentials, HttpConnection connection, CancellationToken cancellationToken)`
	`130`	`+ public static Task<HttpResponseMessage> SendWithNtConnectionAuthAsync(HttpRequestMessage request, ICredentials credentials, HttpConnection connection, HttpConnectionPool connectionPool, CancellationToken cancellationToken)`
`101`	`131`	`{`
`102`		`- return SendWithNtAuthAsync(request, request.RequestUri, credentials, isProxyAuth:false, connection, cancellationToken);`
	`132`	`+ return SendWithNtAuthAsync(request, request.RequestUri, credentials, isProxyAuth:false, connection, connectionPool, cancellationToken);`
`103`	`133`	`}`
`104`	`134`	`}`
`105`	`135`	`}`
Original file line number	Diff line number	Diff line change
`@@ -673,7 +673,7 @@ private async Task SendFramesAsync(Memory<byte> frame)`
`673`	`673`
`674`	`674`	`// Note that this is safe to be called concurrently by multiple threads.`
`675`	`675`
`676`		`- public sealed override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken)`
	`676`	`+ public sealed override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)`
`677`	`677`	`{`
`678`	`678`	`Http2Stream http2Stream = new Http2Stream(this);`
`679`	`679`	`try`
Original file line number	Diff line number	Diff line change
`@@ -682,39 +682,11 @@ public async Task<HttpResponseMessage> SendAsyncCore(HttpRequestMessage request,`
`682`	`682`	`}`
`683`	`683`	`}`
`684`	`684`
`685`		`- public Task<HttpResponseMessage> SendWithNtProxyAuthAsync(HttpRequestMessage request, CancellationToken cancellationToken)`
	`685`	`+ public sealed override Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken)`
`686`	`686`	`{`
`687`		`- if (_pool.AnyProxyKind && _pool.ProxyCredentials != null)`
`688`		`- {`
`689`		`- return AuthenticationHelper.SendWithNtProxyAuthAsync(request, _pool.ProxyUri, _pool.ProxyCredentials, this, cancellationToken);`
`690`		`- }`
`691`		`-`
`692`	`687`	`return SendAsyncCore(request, cancellationToken);`
`693`	`688`	`}`
`694`	`689`
`695`		`- private Task<HttpResponseMessage> SendAsyncInternal(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken)`
`696`		`- {`
`697`		`- if (doRequestAuth && _pool.Settings._credentials != null)`
`698`		`- {`
`699`		`- return AuthenticationHelper.SendWithNtConnectionAuthAsync(request, _pool.Settings._credentials, this, cancellationToken);`
`700`		`- }`
`701`		`-`
`702`		`- return SendWithNtProxyAuthAsync(request, cancellationToken);`
`703`		`- }`
`704`		`-`
`705`		`- public sealed override async Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken)`
`706`		`- {`
`707`		`- Acquire();`
`708`		`- try`
`709`		`- {`
`710`		`- return await SendAsyncInternal(request, doRequestAuth, cancellationToken).ConfigureAwait(false);`
`711`		`- }`
`712`		`- finally`
`713`		`- {`
`714`		`- Release();`
`715`		`- }`
`716`		`- }`
`717`		`-`
`718`	`690`	`private HttpContentWriteStream CreateRequestContentStream(HttpRequestMessage request)`
`719`	`691`	`{`
`720`	`692`	`bool requestTransferEncodingChunked = request.HasHeaders && request.Headers.TransferEncodingChunked == true;`
`@@ -1471,15 +1443,15 @@ private async Task CopyToExactLengthAsync(Stream destination, ulong length, Canc`
`1471`	`1443`	`}`
`1472`	`1444`	`}`
`1473`	`1445`
`1474`		`- private void Acquire()`
	`1446`	`+ internal void Acquire()`
`1475`	`1447`	`{`
`1476`	`1448`	`Debug.Assert(_currentRequest == null);`
`1477`	`1449`	`Debug.Assert(!_inUse);`
`1478`	`1450`
`1479`	`1451`	`_inUse = true;`
`1480`	`1452`	`}`
`1481`	`1453`
`1482`		`- private void Release()`
	`1454`	`+ internal void Release()`
`1483`	`1455`	`{`
`1484`	`1456`	`Debug.Assert(_inUse);`
`1485`	`1457`
Original file line number	Diff line number	Diff line change
`@@ -9,6 +9,6 @@ namespace System.Net.Http`
`9`	`9`	`{`
`10`	`10`	`internal abstract class HttpConnectionBase`
`11`	`11`	`{`
`12`		`- public abstract Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool doRequestAuth, CancellationToken cancellationToken);`
	`12`	`+ public abstract Task<HttpResponseMessage> SendAsync(HttpRequestMessage request, CancellationToken cancellationToken);`
`13`	`13`	`}`
`14`	`14`	`}`