Configure ping in HTTP2

src/libraries/Common/src/System/Net/Http/HttpHandlerDefaults.cs

@@ -27,6 +27,9 @@ internal static class HttpHandlerDefaults
         public static readonly TimeSpan DefaultPooledConnectionLifetime = Timeout.InfiniteTimeSpan;
         public static readonly TimeSpan DefaultPooledConnectionIdleTimeout = TimeSpan.FromMinutes(2);
         public static readonly TimeSpan DefaultExpect100ContinueTimeout = TimeSpan.FromSeconds(1);
+        public static readonly TimeSpan DefaultKeepAlivePingTimeout = TimeSpan.FromSeconds(20);
+        public static readonly TimeSpan DefaultKeepAlivePingDelay = TimeSpan.FromSeconds(0);
+        public const HttpKeepAlivePingPolicy DefaultKeepAlivePingPolicy = HttpKeepAlivePingPolicy.Always;
         public static readonly TimeSpan DefaultConnectTimeout = Timeout.InfiniteTimeSpan;
     }
 }

src/libraries/Common/src/System/Net/Http/HttpKeepAlivePingPolicy.cs

@@ -0,0 +1,11 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+namespace System.Net.Http
+{
+    public enum HttpKeepAlivePingPolicy
+    {
+        WithActiveRequests,
+        Always
+    }
+}

src/libraries/Common/tests/System/Net/Http/Http2LoopbackConnection.cs

@@ -630,6 +630,25 @@ public async Task PingPong()
             Assert.Equal(pingData, pingAck.Data);
         }
 
+        public async Task<PingFrame> ReadPingAsync(TimeSpan timeout)
+        {
+            Frame frame = await ReadFrameAsync(timeout).ConfigureAwait(false);
+            Assert.NotNull(frame);
+            Assert.Equal(FrameType.Ping, frame.Type);
+            Assert.Equal(0, frame.StreamId);
+            Assert.False(frame.AckFlag);
+
+            PingFrame ping = frame as PingFrame;
+            Assert.NotNull(ping);
+            return ping;
+        }
+
+        public async Task SendPingAckAsync(byte[] payload)
+        {
+            PingFrame pingAck = new PingFrame(payload, FrameFlags.Ack, 0);
+            await WriteFrameAsync(pingAck).ConfigureAwait(false);
+        }
+
         public async Task SendDefaultResponseHeadersAsync(int streamId)
         {
             byte[] headers = new byte[] { 0x88 };   // Encoding for ":status: 200"

src/libraries/System.Net.Http.WinHttpHandler/ref/System.Net.Http.WinHttpHandler.cs

@@ -48,4 +48,10 @@ public WinHttpHandler() { }
         protected override void Dispose(bool disposing) { }
         protected override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { throw null; }
     }
+
+    public enum HttpKeepAlivePingPolicy
+    {
+        WithActiveRequests,
+        Always
+    }
 }

src/libraries/System.Net.Http.WinHttpHandler/src/System.Net.Http.WinHttpHandler.csproj

@@ -20,9 +20,9 @@
     <Compile Include="$(CommonPath)\Interop\Windows\Crypt32\Interop.certificates_types.cs"
              Link="Common\Interop\Windows\Crypt32\Interop.certificates_types.cs" />
     <Compile Include="$(CommonPath)\Interop\Windows\Crypt32\Interop.certificates.cs"
-             Link="Common\Interop\Windows\Crypt32\Interop.certificates.cs" />	
+             Link="Common\Interop\Windows\Crypt32\Interop.certificates.cs" />
     <Compile Include="$(CommonPath)Interop\Windows\Kernel32\Interop.FormatMessage.cs"
-             Link="Common\Interop\Windows\Kernel32\Interop.FormatMessage.cs" />	
+             Link="Common\Interop\Windows\Kernel32\Interop.FormatMessage.cs" />
     <Compile Include="$(CommonPath)\Interop\Windows\Kernel32\Interop.GetModuleHandle.cs"
              Link="Common\Interop\Windows\Kernel32\Interop.GetModuleHandle.cs" />
     <Compile Include="$(CommonPath)\Interop\Windows\Interop.HRESULT_FROM_WIN32.cs"
@@ -42,7 +42,7 @@
     <Compile Include="$(CommonPath)\System\Net\HttpKnownHeaderNames.cs"
              Link="Common\System\Net\HttpKnownHeaderNames.cs" />
     <Compile Include="$(CommonPath)\System\Net\HttpKnownHeaderNames.TryGetHeaderName.cs"
-             Link="Common\System\Net\HttpKnownHeaderNames.TryGetHeaderName.cs" />		
+             Link="Common\System\Net\HttpKnownHeaderNames.TryGetHeaderName.cs" />
     <Compile Include="$(CommonPath)System\Net\HttpStatusDescription.cs"
              Link="Common\System\Net\Http\HttpStatusDescription.cs" />
     <Compile Include="$(CommonPath)\System\Net\SecurityProtocol.cs"
@@ -51,6 +51,8 @@
              Link="Common\System\Net\UriScheme.cs" />
     <Compile Include="$(CommonPath)\System\Net\Http\HttpHandlerDefaults.cs"
              Link="Common\System\Net\Http\HttpHandlerDefaults.cs" />
+    <Compile Include="$(CommonPath)\System\Net\Http\HttpKeepAlivePingPolicy.cs"
+             Link="Common\System\Net\Http\HttpKeepAlivePingPolicy.cs" />
     <Compile Include="$(CommonPath)\System\Net\Http\WinInetProxyHelper.cs"
              Link="Common\System\Net\Http\WinInetProxyHelper.cs" />
     <Compile Include="$(CommonPath)\System\Net\Security\CertificateHelper.cs"
@@ -60,7 +62,7 @@
     <Compile Include="$(CommonPath)\System\Runtime\ExceptionServices\ExceptionStackTrace.cs"
              Link="Common\System\Runtime\ExceptionServices\ExceptionStackTrace.cs" />
     <Compile Include="$(CommonPath)\System\Threading\Tasks\RendezvousAwaitable.cs"
-             Link="Common\System\Threading\Tasks\RendezvousAwaitable.cs" />	
+             Link="Common\System\Threading\Tasks\RendezvousAwaitable.cs" />
     <Compile Include="$(CommonPath)System\Threading\Tasks\TaskToApm.cs"
              Link="Common\System\Threading\Tasks\TaskToApm.cs" />
     <Compile Include="System\Net\Http\NetEventSource.WinHttpHandler.cs" />

src/libraries/System.Net.Http/ref/System.Net.Http.cs

@@ -337,6 +337,9 @@ public SocketsHttpHandler() { }
         public System.Net.ICredentials? Credentials { get { throw null; } set { } }
         public System.Net.ICredentials? DefaultProxyCredentials { get { throw null; } set { } }
         public System.TimeSpan Expect100ContinueTimeout { get { throw null; } set { } }
+        public System.TimeSpan KeepAlivePingDelay { get { throw null; } set { } }
+        public System.TimeSpan KeepAlivePingTimeout { get { throw null; } set { } }
+        public HttpKeepAlivePingPolicy KeepAlivePingPolicy { get { throw null; } set { } }
         public int MaxAutomaticRedirections { get { throw null; } set { } }
         public int MaxConnectionsPerServer { get { throw null; } set { } }
         public int MaxResponseDrainSize { get { throw null; } set { } }
@@ -359,6 +362,11 @@ protected override void Dispose(bool disposing) { }
         protected internal override System.Threading.Tasks.Task<System.Net.Http.HttpResponseMessage> SendAsync(System.Net.Http.HttpRequestMessage request, System.Threading.CancellationToken cancellationToken) { throw null; }
         public bool EnableMultipleHttp2Connections { get { throw null; } set { } }
     }
+    public enum HttpKeepAlivePingPolicy
+    {
+        WithActiveRequests,
+        Always
+    }
     public partial class StreamContent : System.Net.Http.HttpContent
     {
         public StreamContent(System.IO.Stream content) { }

src/libraries/System.Net.Http/src/System.Net.Http.csproj

@@ -144,6 +144,7 @@
     <Compile Include="System\Net\Http\SocketsHttpHandler\FailedProxyCache.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2Connection.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2ConnectionException.cs" />
+    <Compile Include="System\Net\Http\SocketsHttpHandler\Http2KeepAlive.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2ProtocolErrorCode.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2ProtocolException.cs" />
     <Compile Include="System\Net\Http\SocketsHttpHandler\Http2Stream.cs" />
@@ -470,6 +471,8 @@
              Link="Common\System\Net\UriScheme.cs" />
     <Compile Include="$(CommonPath)\System\Net\Http\HttpHandlerDefaults.cs"
              Link="Common\System\Net\Http\HttpHandlerDefaults.cs" />
+    <Compile Include="$(CommonPath)\System\Net\Http\HttpKeepAlivePingPolicy.cs"
+             Link="Common\System\Net\Http\HttpKeepAlivePingPolicy.cs" />
     <Compile Include="$(CommonPath)\System\Net\Http\WinInetProxyHelper.cs"
              Link="Common\System\Net\Http\WinInetProxyHelper.cs" />
     <Compile Include="$(CommonPath)\System\Net\Security\CertificateHelper.cs"

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2Connection.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System;
 using System.Buffers.Binary;
 using System.Collections.Generic;
 using System.Diagnostics;
@@ -96,6 +97,8 @@ internal sealed partial class Http2Connection : HttpConnectionBase, IDisposable
         // Channel options for creating _writeChannel
         private static readonly UnboundedChannelOptions s_channelOptions = new UnboundedChannelOptions() { SingleReader = true };
 
+        private Http2KeepAlive _keepAlive;
+
         public Http2Connection(HttpConnectionPool pool, Connection connection)
         {
             _pool = pool;
@@ -119,6 +122,8 @@ public Http2Connection(HttpConnectionPool pool, Connection connection)
             _pendingWindowUpdate = 0;
             _idleSinceTickCount = Environment.TickCount64;
 
+            _keepAlive = new Http2KeepAlive(this, _pool.Settings);
+
             if (NetEventSource.Log.IsEnabled()) TraceConnection(_stream);
         }
 
@@ -279,6 +284,8 @@ private async Task ProcessIncomingFramesAsync()
                     frameHeader = await ReadFrameAsync().ConfigureAwait(false);
                     if (NetEventSource.Log.IsEnabled()) Trace($"Frame {frameNum}: {frameHeader}.");
 
+                    _keepAlive.ProcessFrame();
+
                     // Process the frame.
                     switch (frameHeader.Type)
                     {
@@ -648,12 +655,6 @@ private void ProcessPingFrame(FrameHeader frameHeader)
                 ThrowProtocolError();
             }
 
-            if (frameHeader.AckFlag)
-            {
-                // We never send PING, so an ACK indicates a protocol error
-                ThrowProtocolError();
-            }
-
             if (frameHeader.PayloadLength != FrameHeader.PingLength)
             {
                 ThrowProtocolError(Http2ProtocolErrorCode.FrameSizeError);
@@ -666,8 +667,15 @@ private void ProcessPingFrame(FrameHeader frameHeader)
             ReadOnlySpan<byte> pingContent = _incomingBuffer.ActiveSpan.Slice(0, FrameHeader.PingLength);
             long pingContentLong = BinaryPrimitives.ReadInt64BigEndian(pingContent);
 
-            LogExceptions(SendPingAckAsync(pingContentLong));
-
+            if (frameHeader.AckFlag)
+            {
+                if (!_keepAlive.ProcessPingAck(pingContentLong))
+                    ThrowProtocolError();
+            }
+            else
+            {
+                LogExceptions(SendPingAckAsync(pingContentLong));
+            }
             _incomingBuffer.Discard(frameHeader.PayloadLength);
         }
 
@@ -931,6 +939,21 @@ private Task SendPingAckAsync(long pingContent) =>
                 return true;
             });
 
+        /// <param name="pingContent">The 8-byte ping content to send, read as a big-endian integer.</param>
+        private Task SendPingAsync(long pingContent) =>
+            PerformWriteAsync(FrameHeader.Size + FrameHeader.PingLength, (thisRef: this, pingContent), static (state, writeBuffer) =>
+            {
+                if (NetEventSource.Log.IsEnabled()) state.thisRef.Trace("Started writing.");
+
+                Debug.Assert(sizeof(long) == FrameHeader.PingLength);
+
+                Span<byte> span = writeBuffer.Span;
+                FrameHeader.WriteTo(span, FrameHeader.PingLength, FrameType.Ping, FrameFlags.None, streamId: 0);
+                BinaryPrimitives.WriteInt64BigEndian(span.Slice(FrameHeader.Size), state.pingContent);
+
+                return true;
+            });
+
         private Task SendRstStreamAsync(int streamId, Http2ProtocolErrorCode errorCode) =>
             PerformWriteAsync(FrameHeader.Size + FrameHeader.RstStreamLength, (thisRef: this, streamId, errorCode), static (s, writeBuffer) =>
             {
@@ -943,6 +966,24 @@ private Task SendRstStreamAsync(int streamId, Http2ProtocolErrorCode errorCode)
                 return true;
             });
 
+
+        internal void HeartBeat()
+        {
+            if (_disposed)
+                return;
+
+            try
+            {
+                _keepAlive.VerifyKeepAlive();
+            }
+            catch (Exception e)
+            {
+                if (NetEventSource.Log.IsEnabled()) Trace($"{nameof(ProcessIncomingFramesAsync)}: {e.Message}");
+
+                Abort(e);
+            }
+        }
+
         private static (ReadOnlyMemory<byte> first, ReadOnlyMemory<byte> rest) SplitBuffer(ReadOnlyMemory<byte> buffer, int maxSize) =>
             buffer.Length > maxSize ?
                 (buffer.Slice(0, maxSize), buffer.Slice(maxSize)) :

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/Http2KeepAlive.cs

@@ -0,0 +1,99 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System;
+using System.Buffers.Binary;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Diagnostics.CodeAnalysis;
+using System.IO;
+using System.Net.Http.Headers;
+using System.Net.Http.HPack;
+using System.Net.Security;
+using System.Runtime.CompilerServices;
+using System.Text;
+using System.Threading;
+using System.Threading.Channels;
+using System.Threading.Tasks;
+
+namespace System.Net.Http
+{
+    internal sealed partial class Http2Connection
+    {
+        internal enum KeepAliveState
+        {
+            None,
+            PingSent
+        }
+
+        internal class Http2KeepAlive
+        {
+
+            private long _pingPayload;
+
+            private readonly TimeSpan _keepAlivePingDelay;
+            private readonly TimeSpan _keepAlivePingTimeout;
+            private DateTimeOffset _nextPingRequestTimestamp;
+            private DateTimeOffset _pingTimeoutTimestamp;
+            private HttpKeepAlivePingPolicy _keepAlivePingPolicy;
+            private KeepAliveState _state;
+            private Http2Connection _connection;
+
+            public Http2KeepAlive(Http2Connection connection, HttpConnectionSettings settings)
+            {
+                _keepAlivePingDelay = settings._keepAlivePingDelay;
+                _keepAlivePingTimeout = settings._keepAlivePingTimeout;
+                _nextPingRequestTimestamp = DateTimeOffset.Now.Add(settings._keepAlivePingDelay);
+                _keepAlivePingPolicy = settings._keepAlivePingPolicy;
+                _connection = connection;
+            }
+
+            public void ProcessFrame()
+            {
+                _nextPingRequestTimestamp = DateTimeOffset.Now.Add(_keepAlivePingDelay);
+            }
+
+            public bool ProcessPingAck(long payload)
+            {
+                if (_state != KeepAliveState.PingSent)
+                    return false;
+                if (Interlocked.Read(ref _pingPayload) != payload)
+                    return false;
+                _state = KeepAliveState.None;
+                ProcessFrame();
+                return true;
+            }
+
+            public void VerifyKeepAlive()
+            {
+                if (_keepAlivePingPolicy == HttpKeepAlivePingPolicy.WithActiveRequests && _connection._httpStreams.Count == 0)
+                    return;
+
+                var now = DateTimeOffset.Now;
+                switch (_state)
+                {
+                    case KeepAliveState.None:
+                        // Check whether keep alive delay has passed since last frame received
+                        if (_keepAlivePingDelay > TimeSpan.Zero && now > _nextPingRequestTimestamp)
+                        {
+                            // Set the status directly to ping sent and set the timestamp
+                            _state = KeepAliveState.PingSent;
+                            _pingTimeoutTimestamp = now.Add(_keepAlivePingTimeout);
+                            Interlocked.Increment(ref _pingPayload);
+                            _connection.SendPingAsync(_pingPayload);
+                            return;
+                        }
+                        break;
+                    case KeepAliveState.PingSent:
+                        if (_keepAlivePingTimeout != TimeSpan.MaxValue)
+                        {
+                            if (now > _pingTimeoutTimestamp)
+                                Http2Connection.ThrowProtocolError();
+                        }
+
+                        break;
+                }
+            }
+        }
+    }
+}

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs

@@ -1689,6 +1689,17 @@ private static bool GetIsWindows7Or2008R2()
             return false;
         }
 
+        internal void HeartBeat()
+        {
+            Http2Connection[]? localHttp2Connections = _http2Connections;
+            if (localHttp2Connections != null)
+            {
+                foreach (var http2Connection in localHttp2Connections)
+                    http2Connection?.HeartBeat();
+            }
+        }
+
+
         // For diagnostic purposes
         public override string ToString() =>
             $"{nameof(HttpConnectionPool)} " +