Don't emit TE header or body for non-body responses

Resolves #952

Author: benaadams

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/Frame.cs

@@ -58,6 +58,7 @@ public abstract partial class Frame : ConnectionContext, IFrameControl
 
         protected RequestProcessingStatus _requestProcessingStatus;
         protected bool _keepAlive;
+        private bool _canHaveBody;
         private bool _autoChunk;
         protected Exception _applicationException;
 
@@ -465,6 +466,9 @@ public void Write(ArraySegment<byte> data)
         {
             ProduceStartAndFireOnStarting().GetAwaiter().GetResult();
 
+            // Don't write to body for HEAD requests or 101, 204, 205, 304 responses.
+            if (!_canHaveBody) return;
+
             if (_autoChunk)
             {
                 if (data.Count == 0)
@@ -486,6 +490,9 @@ public Task WriteAsync(ArraySegment<byte> data, CancellationToken cancellationTo
                 return WriteAsyncAwaited(data, cancellationToken);
             }
 
+            // Don't write to body for HEAD requests or 101, 204, 205, 304 responses.
+            if (!_canHaveBody) return TaskUtilities.CompletedTask;
+
             if (_autoChunk)
             {
                 if (data.Count == 0)
@@ -504,6 +511,9 @@ public async Task WriteAsyncAwaited(ArraySegment<byte> data, CancellationToken c
         {
             await ProduceStartAndFireOnStarting();
 
+            // Don't write to body for HEAD requests or 101, 204, 205, 304 responses.
+            if (!_canHaveBody) return;
+
             if (_autoChunk)
             {
                 if (data.Count == 0)
@@ -710,10 +720,12 @@ private void CreateResponseHeader(
             bool appCompleted)
         {
             var responseHeaders = FrameResponseHeaders;
-            responseHeaders.SetReadOnly();
 
             var hasConnection = responseHeaders.HasConnection;
 
+            // Set whether response can have body
+            _canHaveBody = StatusCanHaveBody(StatusCode) && Method != "HEAD";
+
             var end = SocketOutput.ProducingStart();
             if (_keepAlive && hasConnection)
             {
@@ -727,39 +739,49 @@ private void CreateResponseHeader(
                 }
             }
 
-            if (_keepAlive && !responseHeaders.HasTransferEncoding && !responseHeaders.HasContentLength)
+            if (_canHaveBody)
             {
-                if (appCompleted)
+                if (_keepAlive && !responseHeaders.HasTransferEncoding && !responseHeaders.HasContentLength)
                 {
-                    // Don't set the Content-Length or Transfer-Encoding headers
-                    // automatically for HEAD requests or 101, 204, 205, 304 responses.
-                    if (Method != "HEAD" && StatusCanHaveBody(StatusCode))
+                    if (appCompleted)
                     {
                         // Since the app has completed and we are only now generating
                         // the headers we can safely set the Content-Length to 0.
                         responseHeaders.SetRawContentLength("0", _bytesContentLengthZero);
                     }
-                }
-                else
-                {
-                    // Note for future reference: never change this to set _autoChunk to true on HTTP/1.0
-                    // connections, even if we were to infer the client supports it because an HTTP/1.0 request
-                    // was received that used chunked encoding. Sending a chunked response to an HTTP/1.0
-                    // client would break compliance with RFC 7230 (section 3.3.1):
-                    //
-                    // A server MUST NOT send a response containing Transfer-Encoding unless the corresponding
-                    // request indicates HTTP/1.1 (or later).
-                    if (_httpVersion == HttpVersionType.Http11)
-                    {
-                        _autoChunk = true;
-                        responseHeaders.SetRawTransferEncoding("chunked", _bytesTransferEncodingChunked);
-                    }
                     else
                     {
-                        _keepAlive = false;
+                        // Note for future reference: never change this to set _autoChunk to true on HTTP/1.0
+                        // connections, even if we were to infer the client supports it because an HTTP/1.0 request
+                        // was received that used chunked encoding. Sending a chunked response to an HTTP/1.0
+                        // client would break compliance with RFC 7230 (section 3.3.1):
+                        //
+                        // A server MUST NOT send a response containing Transfer-Encoding unless the corresponding
+                        // request indicates HTTP/1.1 (or later).
+                        if (_httpVersion == HttpVersionType.Http11)
+                        {
+                            _autoChunk = true;
+                            responseHeaders.SetRawTransferEncoding("chunked", _bytesTransferEncodingChunked);
+                        }
+                        else
+                        {
+                            _keepAlive = false;
+                        }
                     }
                 }
             }
+            else
+            {
+                // Don't set the Content-Length or Transfer-Encoding headers
+                // automatically for HEAD requests or 101, 204, 205, 304 responses.
+                if (responseHeaders.HasTransferEncoding)
+                {
+                    // Remove Transfer-Encoding encoding header if it exists
+                    responseHeaders.Remove("Transfer-Encoding");
+                }
+            }
+
+            responseHeaders.SetReadOnly();
 
             if (!_keepAlive && !hasConnection && _httpVersion != HttpVersionType.Http10)
             {

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Http/FrameHeaders.cs

@@ -196,7 +196,7 @@ bool ICollection<KeyValuePair<string, StringValues>>.Remove(KeyValuePair<string,
                 RemoveFast(item.Key);
         }
 
-        bool IDictionary<string, StringValues>.Remove(string key)
+        public bool Remove(string key)
         {
             if (_isReadOnly)
             {