Avoid zero-length writes to flush connection filter stream

- This works around a zero-length write bug in SslStream.
- We already assume connection filter streams auto flush.

#1195

Author: halter73

src/Microsoft.AspNetCore.Server.Kestrel/Filter/Internal/StreamSocketOutput.cs

@@ -8,6 +8,7 @@
 using System.Threading.Tasks;
 using Microsoft.AspNetCore.Server.Kestrel.Internal.Http;
 using Microsoft.AspNetCore.Server.Kestrel.Internal.Infrastructure;
+using Microsoft.Extensions.Internal;
 
 namespace Microsoft.AspNetCore.Server.Kestrel.Filter.Internal
 {
@@ -34,11 +35,6 @@ public StreamSocketOutput(string connectionId, Stream outputStream, MemoryPool m
 
         public void Write(ArraySegment<byte> buffer, bool chunk)
         {
-            if (buffer.Count == 0 )
-            {
-                return;
-            }
-
             if (chunk && buffer.Array != null)
             {
                 var beginChunkBytes = ChunkWriter.BeginChunkBytes(buffer.Count);
@@ -117,5 +113,15 @@ public void ProducingComplete(MemoryPoolIterator end)
 
             end.Block.Pool.Return(end.Block);
         }
+
+        // Flush no-ops. We rely on connection filter streams to auto-flush.
+        public void Flush()
+        {
+        }
+
+        public Task FlushAsync(CancellationToken cancellationToken)
+        {
+            return TaskCache.CompletedTask;
+        }
     }
 }

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

@@ -26,7 +26,6 @@ public abstract partial class Frame : IFrameControl
     {
         private static readonly ArraySegment<byte> _endChunkedResponseBytes = CreateAsciiByteArraySegment("0\r\n\r\n");
         private static readonly ArraySegment<byte> _continueBytes = CreateAsciiByteArraySegment("HTTP/1.1 100 Continue\r\n\r\n");
-        private static readonly ArraySegment<byte> _emptyData = new ArraySegment<byte>(new byte[0]);
 
         private static readonly byte[] _bytesConnectionClose = Encoding.ASCII.GetBytes("\r\nConnection: close");
         private static readonly byte[] _bytesConnectionKeepAlive = Encoding.ASCII.GetBytes("\r\nConnection: keep-alive");
@@ -506,13 +505,13 @@ protected async Task FireOnCompleted()
         public void Flush()
         {
             ProduceStartAndFireOnStarting().GetAwaiter().GetResult();
-            SocketOutput.Write(_emptyData);
+            SocketOutput.Flush();
         }
 
         public async Task FlushAsync(CancellationToken cancellationToken)
         {
             await ProduceStartAndFireOnStarting();
-            await SocketOutput.WriteAsync(_emptyData, cancellationToken: cancellationToken);
+            await SocketOutput.FlushAsync(cancellationToken);
         }
 
         public void Write(ArraySegment<byte> data)
@@ -768,7 +767,7 @@ private async Task ProduceEndAwaited()
             ProduceStart(appCompleted: true);
 
             // Force flush
-            await SocketOutput.WriteAsync(_emptyData);
+            await SocketOutput.FlushAsync();
 
             await WriteSuffix();
         }

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

@@ -15,6 +15,8 @@ public interface ISocketOutput
     {
         void Write(ArraySegment<byte> buffer, bool chunk = false);
         Task WriteAsync(ArraySegment<byte> buffer, bool chunk = false, CancellationToken cancellationToken = default(CancellationToken));
+        void Flush();
+        Task FlushAsync(CancellationToken cancellationToken = default(CancellationToken));
 
         /// <summary>
         /// Returns an iterator pointing to the tail of the response buffer. Response data can be appended

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

@@ -21,6 +21,7 @@ public class SocketOutput : ISocketOutput
         // Well behaved WriteAsync users should await returned task, so there is no need to allocate more per connection by default
         private const int _initialTaskQueues = 1;
 
+        private static readonly ArraySegment<byte> _emptyData = new ArraySegment<byte>(new byte[0]);
         private static readonly WaitCallback _returnBlocks = (state) => ReturnBlocks((MemoryPoolBlock)state);
         private static readonly Action<object> _connectionCancellation = (state) => ((SocketOutput)state).CancellationTriggered();
 
@@ -534,6 +535,16 @@ Task ISocketOutput.WriteAsync(ArraySegment<byte> buffer, bool chunk, Cancellatio
             return WriteAsync(buffer, cancellationToken, chunk);
         }
 
+        void ISocketOutput.Flush()
+        {
+            WriteAsync(_emptyData, default(CancellationToken), isSync: true).GetAwaiter().GetResult();
+        }
+
+        Task ISocketOutput.FlushAsync(CancellationToken cancellationToken)
+        {
+            return WriteAsync(_emptyData, cancellationToken);
+        }
+
         private static void BytesBetween(MemoryPoolIterator start, MemoryPoolIterator end, out int bytes, out int buffers)
         {
             if (start.Block == end.Block)

test/Microsoft.AspNetCore.Server.KestrelTests/TestHelpers/MockSocketOuptut.cs

@@ -29,5 +29,14 @@ public void Write(ArraySegment<byte> buffer, bool chunk = false)
         {
             return TaskCache.CompletedTask;
         }
+
+        public void Flush()
+        {
+        }
+
+        public Task FlushAsync(CancellationToken cancellationToken = new CancellationToken())
+        {
+            return TaskCache.CompletedTask;
+        }
     }
 }