Do not close connection for http1.0 when client request connection keep-alive (#56558)

Author: xiaozhao018

src/Servers/HttpSys/src/RequestProcessing/Response.cs

@@ -391,6 +391,7 @@ internal uint ComputeHeaders(long writeCount, bool endOfRequest = false)
         var requestConnectionString = Request.Headers[HeaderNames.Connection];
         var isHeadRequest = Request.IsHeadMethod;
         var requestCloseSet = Matches(Constants.Close, requestConnectionString);
+        var requestConnectionKeepAliveSet = Matches(Constants.KeepAlive, requestConnectionString);
 
         // Gather everything the app may have set on the response:
         // Http.Sys does not allow us to specify the response protocol version, assume this is a HTTP/1.1 response when making decisions.
@@ -403,7 +404,13 @@ internal uint ComputeHeaders(long writeCount, bool endOfRequest = false)
 
         // Determine if the connection will be kept alive or closed.
         var keepConnectionAlive = true;
-        if (requestVersion <= Constants.V1_0 // Http.Sys does not support "Keep-Alive: true" or "Connection: Keep-Alive"
+
+        // An HTTP/1.1 server may also establish persistent connections with
+        // HTTP/1.0 clients upon receipt of a Keep-Alive connection token.
+        // However, a persistent connection with an HTTP/1.0 client cannot make
+        // use of the chunked transfer-coding. From: https://www.rfc-editor.org/rfc/rfc2068#section-19.7.1
+        if (requestVersion < Constants.V1_0
+            || (requestVersion == Constants.V1_0 && (!requestConnectionKeepAliveSet || responseChunkedSet))
             || (requestVersion == Constants.V1_1 && requestCloseSet)
             || responseCloseSet)
         {

src/Servers/HttpSys/test/FunctionalTests/Listener/ResponseHeaderTests.cs

@@ -6,6 +6,7 @@
 using System.Linq;
 using System.Net;
 using System.Net.Http;
+using System.Net.Sockets;
 using System.Text;
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.InternalTesting;
@@ -207,20 +208,66 @@ public async Task ResponseHeaders_11HeadRequestStatusCodeWithoutBody_NoContentLe
     }
 
     [ConditionalFact]
-    public async Task ResponseHeaders_HTTP10KeepAliveRequest_Gets11Close()
+    public async Task ResponseHeaders_HTTP10KeepAliveRequest_KeepAliveHeader_Gets11NoClose()
+    {
+        string address;
+        using (var server = Utilities.CreateHttpServer(out address))
+        {
+            // Track the number of times ConnectCallback is invoked to ensure the underlying socket wasn't closed.
+            int connectCallbackInvocations = 0;
+            var handler = new SocketsHttpHandler();
+            handler.ConnectCallback = (context, cancellationToken) =>
+            {
+                Interlocked.Increment(ref connectCallbackInvocations);
+                return ConnectCallback(context, cancellationToken);
+            };
+
+            using (var client = new HttpClient(handler))
+            {
+                // Send the first request
+                Task<HttpResponseMessage> responseTask = SendRequestAsync(address, usehttp11: false, sendKeepAlive: true, httpClient: client);
+                var context = await server.AcceptAsync(Utilities.DefaultTimeout).Before(responseTask);
+                context.Dispose();
+
+                HttpResponseMessage response = await responseTask;
+                response.EnsureSuccessStatusCode();
+                Assert.Equal(new Version(1, 1), response.Version);
+                Assert.Null(response.Headers.ConnectionClose);
+
+                // Send the second request
+                responseTask = SendRequestAsync(address, usehttp11: false, sendKeepAlive: true, httpClient: client);
+                context = await server.AcceptAsync(Utilities.DefaultTimeout).Before(responseTask);
+                context.Dispose();
+
+                response = await responseTask;
+                response.EnsureSuccessStatusCode();
+                Assert.Equal(new Version(1, 1), response.Version);
+                Assert.Null(response.Headers.ConnectionClose);
+            }
+
+            // Verify that ConnectCallback was only called once
+            Assert.Equal(1, connectCallbackInvocations);
+        }
+    }
+
+    [ConditionalFact]
+    public async Task ResponseHeaders_HTTP10KeepAliveRequest_ChunkedTransferEncoding_Gets11Close()
     {
         string address;
         using (var server = Utilities.CreateHttpServer(out address))
         {
-            // Http.Sys does not support 1.0 keep-alives.
             Task<HttpResponseMessage> responseTask = SendRequestAsync(address, usehttp11: false, sendKeepAlive: true);
 
             var context = await server.AcceptAsync(Utilities.DefaultTimeout).Before(responseTask);
+            context.Response.Headers["Transfer-Encoding"] = new string[] { "chunked" };
+            var responseBytes = Encoding.ASCII.GetBytes("10\r\nManually Chunked\r\n0\r\n\r\n");
+            await context.Response.Body.WriteAsync(responseBytes, 0, responseBytes.Length);
             context.Dispose();
 
             HttpResponseMessage response = await responseTask;
             response.EnsureSuccessStatusCode();
             Assert.Equal(new Version(1, 1), response.Version);
+            Assert.True(response.Headers.TransferEncodingChunked.HasValue, "Chunked");
             Assert.True(response.Headers.ConnectionClose.Value);
         }
     }
@@ -289,8 +336,9 @@ public async Task AddingControlCharactersToHeadersThrows(string key, string valu
         }
     }
 
-    private async Task<HttpResponseMessage> SendRequestAsync(string uri, bool usehttp11 = true, bool sendKeepAlive = false)
+    private async Task<HttpResponseMessage> SendRequestAsync(string uri, bool usehttp11 = true, bool sendKeepAlive = false, HttpClient httpClient = null)
     {
+        httpClient ??= _client;
         var request = new HttpRequestMessage(HttpMethod.Get, uri);
         if (!usehttp11)
         {
@@ -300,7 +348,7 @@ private async Task<HttpResponseMessage> SendRequestAsync(string uri, bool usehtt
         {
             request.Headers.Add("Connection", "Keep-Alive");
         }
-        return await _client.SendAsync(request);
+        return await httpClient.SendAsync(request);
     }
 
     private async Task<HttpResponseMessage> SendHeadRequestAsync(string uri, bool usehttp11 = true)
@@ -312,4 +360,19 @@ private async Task<HttpResponseMessage> SendHeadRequestAsync(string uri, bool us
         }
         return await _client.SendAsync(request);
     }
+
+    private static async ValueTask<Stream> ConnectCallback(SocketsHttpConnectionContext connectContext, CancellationToken ct)
+    {
+        var s = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true };
+        try
+        {
+            await s.ConnectAsync(connectContext.DnsEndPoint, ct);
+            return new NetworkStream(s, ownsSocket: true);
+        }
+        catch
+        {
+            s.Dispose();
+            throw;
+        }
+    }
 }

src/Shared/HttpSys/Constants.cs

@@ -9,6 +9,7 @@ internal static class Constants
     internal const string HttpsScheme = "https";
     internal const string Chunked = "chunked";
     internal const string Close = "close";
+    internal const string KeepAlive = "keep-alive";
     internal const string Zero = "0";
     internal const string SchemeDelimiter = "://";
     internal const string DefaultServerAddress = "http://localhost:5000";