Add HttpProtocol (#18049)

Author: JamesNK

src/Hosting/TestHost/src/ClientHandler.cs

@@ -100,7 +100,7 @@ protected override async Task<HttpResponseMessage> SendAsync(
                 if (request.Version == HttpVersion.Version20)
                 {
                     // https://tools.ietf.org/html/rfc7540
-                    req.Protocol = "HTTP/2";
+                    req.Protocol =  HttpProtocol.Http2;
                 }
                 else
                 {

src/Hosting/TestHost/src/HttpContextBuilder.cs

@@ -41,7 +41,7 @@ internal HttpContextBuilder(ApplicationWrapper application, bool allowSynchronou
             _requestLifetimeFeature = new RequestLifetimeFeature(Abort);
 
             var request = _httpContext.Request;
-            request.Protocol = "HTTP/1.1";
+            request.Protocol = HttpProtocol.Http11;
             request.Method = HttpMethods.Get;
 
             _requestPipe = new Pipe();
@@ -98,7 +98,7 @@ internal Task<HttpContext> SendAsync(CancellationToken cancellationToken)
             async Task RunRequestAsync()
             {
                 // HTTP/2 specific features must be added after the request has been configured.
-                if (string.Equals("HTTP/2", _httpContext.Request.Protocol, StringComparison.OrdinalIgnoreCase))
+                if (HttpProtocol.IsHttp2(_httpContext.Request.Protocol))
                 {
                     _httpContext.Features.Set<IHttpResetFeature>(this);
                 }

src/Hosting/TestHost/src/RequestFeature.cs

@@ -16,7 +16,7 @@ public RequestFeature()
             Method = "GET";
             Path = "";
             PathBase = "";
-            Protocol = "HTTP/1.1";
+            Protocol = HttpProtocol.Http11;
             QueryString = "";
             Scheme = "http";
         }

src/Hosting/TestHost/test/ClientHandlerTests.cs

@@ -27,7 +27,7 @@ public Task ExpectedKeysAreAvailable()
             var handler = new ClientHandler(new PathString("/A/Path/"), new DummyApplication(context =>
             {
                 // TODO: Assert.True(context.RequestAborted.CanBeCanceled);
-                Assert.Equal("HTTP/1.1", context.Request.Protocol);
+                Assert.Equal(HttpProtocol.Http11, context.Request.Protocol);
                 Assert.Equal("GET", context.Request.Method);
                 Assert.Equal("https", context.Request.Scheme);
                 Assert.Equal("/A/Path", context.Request.PathBase.Value);
@@ -53,7 +53,7 @@ public Task ExpectedKeysAreInFeatures()
             var handler = new ClientHandler(new PathString("/A/Path/"), new InspectingApplication(features =>
             {
                 Assert.True(features.Get<IHttpRequestLifetimeFeature>().RequestAborted.CanBeCanceled);
-                Assert.Equal("HTTP/1.1", features.Get<IHttpRequestFeature>().Protocol);
+                Assert.Equal(HttpProtocol.Http11, features.Get<IHttpRequestFeature>().Protocol);
                 Assert.Equal("GET", features.Get<IHttpRequestFeature>().Method);
                 Assert.Equal("https", features.Get<IHttpRequestFeature>().Scheme);
                 Assert.Equal("/A/Path", features.Get<IHttpRequestFeature>().PathBase);

src/Hosting/TestHost/test/HttpContextBuilderTests.cs

@@ -33,7 +33,7 @@ public async Task ExpectedValuesAreAvailable()
             });
 
             Assert.True(context.RequestAborted.CanBeCanceled);
-            Assert.Equal("HTTP/1.1", context.Request.Protocol);
+            Assert.Equal(HttpProtocol.Http11, context.Request.Protocol);
             Assert.Equal("POST", context.Request.Method);
             Assert.Equal("https", context.Request.Scheme);
             Assert.Equal("example.com", context.Request.Host.Value);

src/Http/Http.Abstractions/ref/Microsoft.AspNetCore.Http.Abstractions.netcoreapp.cs

@@ -250,6 +250,18 @@ public static partial class HttpMethods
         public static bool IsPut(string method) { throw null; }
         public static bool IsTrace(string method) { throw null; }
     }
+    public static partial class HttpProtocol
+    {
+        public static readonly string Http10;
+        public static readonly string Http11;
+        public static readonly string Http2;
+        public static readonly string Http3;
+        public static string GetHttpProtocol(System.Version version) { throw null; }
+        public static bool IsHttp10(string protocol) { throw null; }
+        public static bool IsHttp11(string protocol) { throw null; }
+        public static bool IsHttp2(string protocol) { throw null; }
+        public static bool IsHttp3(string protocol) { throw null; }
+    }
     public abstract partial class HttpRequest
     {
         protected HttpRequest() { }

src/Http/Http.Abstractions/src/HttpProtocol.cs

@@ -0,0 +1,96 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+
+namespace Microsoft.AspNetCore.Http
+{
+    /// <summary>
+    /// Contains methods to verify the request protocol version of an HTTP request. 
+    /// </summary>
+    public static class HttpProtocol
+    {
+        // We are intentionally using 'static readonly' here instead of 'const'.
+        // 'const' values would be embedded into each assembly that used them
+        // and each consuming assembly would have a different 'string' instance.
+        // Using .'static readonly' means that all consumers get these exact same
+        // 'string' instance, which means the 'ReferenceEquals' checks below work
+        // and allow us to optimize comparisons when these constants are used.
+
+        // Please do NOT change these to 'const'
+        public static readonly string Http10 = "HTTP/1.0";
+        public static readonly string Http11 = "HTTP/1.1";
+        public static readonly string Http2 = "HTTP/2";
+        public static readonly string Http3 = "HTTP/3";
+
+        /// <summary>
+        /// Returns a value that indicates if the HTTP request protocol is HTTP/1.0. 
+        /// </summary>
+        /// <param name="protocol">The HTTP request protocol.</param>
+        /// <returns>
+        /// <see langword="true" /> if the protocol is HTTP/1.0; otherwise, <see langword="false" />.
+        /// </returns>
+        public static bool IsHttp10(string protocol)
+        {
+            return object.ReferenceEquals(Http10, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http10, protocol);
+        }
+
+        /// <summary>
+        /// Returns a value that indicates if the HTTP request protocol is HTTP/1.1. 
+        /// </summary>
+        /// <param name="protocol">The HTTP request protocol.</param>
+        /// <returns>
+        /// <see langword="true" /> if the protocol is HTTP/1.1; otherwise, <see langword="false" />.
+        /// </returns>
+        public static bool IsHttp11(string protocol)
+        {
+            return object.ReferenceEquals(Http11, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http11, protocol);
+        }
+
+        /// <summary>
+        /// Returns a value that indicates if the HTTP request protocol is HTTP/2. 
+        /// </summary>
+        /// <param name="protocol">The HTTP request protocol.</param>
+        /// <returns>
+        /// <see langword="true" /> if the protocol is HTTP/2; otherwise, <see langword="false" />.
+        /// </returns>
+        public static bool IsHttp2(string protocol)
+        {
+            return object.ReferenceEquals(Http2, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http2, protocol);
+        }
+
+        /// <summary>
+        /// Returns a value that indicates if the HTTP request protocol is HTTP/3. 
+        /// </summary>
+        /// <param name="protocol">The HTTP request protocol.</param>
+        /// <returns>
+        /// <see langword="true" /> if the protocol is HTTP/3; otherwise, <see langword="false" />.
+        /// </returns>
+        public static bool IsHttp3(string protocol)
+        {
+            return object.ReferenceEquals(Http3, protocol) || StringComparer.OrdinalIgnoreCase.Equals(Http3, protocol);
+        }
+
+        /// <summary>
+        /// Gets the HTTP request protocol for the specified <see cref="Version"/>.
+        /// </summary>
+        /// <param name="version">The version.</param>
+        /// <returns>A HTTP request protocol.</returns>
+        public static string GetHttpProtocol(Version version)
+        {
+            if (version == null)
+            {
+                throw new ArgumentNullException(nameof(version));
+            }
+
+            return version switch
+            {
+                { Major: 3, Minor: 0 } => Http3,
+                { Major: 2, Minor: 0 } => Http2,
+                { Major: 1, Minor: 1 } => Http11,
+                { Major: 1, Minor: 0 } => Http10,
+                _ => throw new ArgumentOutOfRangeException(nameof(version), "Version doesn't map to a known HTTP protocol.")
+            };
+        }
+    }
+}

src/Http/Http.Abstractions/test/HttpProtocolTests.cs

@@ -0,0 +1,117 @@
+// Copyright (c) .NET Foundation. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System;
+using Xunit;
+
+namespace Microsoft.AspNetCore.Http.Abstractions
+{
+    public class HttpProtocolTests
+    {
+        [Fact]
+        public void Http3_Success()
+        {
+            Assert.Equal("HTTP/3", HttpProtocol.Http3);
+        }
+
+        [Theory]
+        [InlineData("HTTP/3", true)]
+        [InlineData("http/3", true)]
+        [InlineData("HTTP/1.1", false)]
+        [InlineData("HTTP/3.0", false)]
+        [InlineData("HTTP/1", false)]
+        [InlineData(" HTTP/3", false)]
+        [InlineData("HTTP/3 ", false)]
+        public void IsHttp3_Success(string protocol, bool match)
+        {
+            Assert.Equal(match, HttpProtocol.IsHttp3(protocol));
+        }
+
+        [Fact]
+        public void Http2_Success()
+        {
+            Assert.Equal("HTTP/2", HttpProtocol.Http2);
+        }
+
+        [Theory]
+        [InlineData("HTTP/2", true)]
+        [InlineData("http/2", true)]
+        [InlineData("HTTP/1.1", false)]
+        [InlineData("HTTP/2.0", false)]
+        [InlineData("HTTP/1", false)]
+        [InlineData(" HTTP/2", false)]
+        [InlineData("HTTP/2 ", false)]
+        public void IsHttp2_Success(string protocol, bool match)
+        {
+            Assert.Equal(match, HttpProtocol.IsHttp2(protocol));
+        }
+
+        [Fact]
+        public void Http11_Success()
+        {
+            Assert.Equal("HTTP/1.1", HttpProtocol.Http11);
+        }
+
+        [Theory]
+        [InlineData("HTTP/1.1", true)]
+        [InlineData("http/1.1", true)]
+        [InlineData("HTTP/2", false)]
+        [InlineData("HTTP/1.0", false)]
+        [InlineData("HTTP/1", false)]
+        [InlineData(" HTTP/1.1", false)]
+        [InlineData("HTTP/1.1 ", false)]
+        public void IsHttp11_Success(string protocol, bool match)
+        {
+            Assert.Equal(match, HttpProtocol.IsHttp11(protocol));
+        }
+
+        [Fact]
+        public void Http10_Success()
+        {
+            Assert.Equal("HTTP/1.0", HttpProtocol.Http10);
+        }
+
+        [Theory]
+        [InlineData("HTTP/1.0", true)]
+        [InlineData("http/1.0", true)]
+        [InlineData("HTTP/2", false)]
+        [InlineData("HTTP/1.1", false)]
+        [InlineData("HTTP/1", false)]
+        [InlineData(" HTTP/1.0", false)]
+        [InlineData("HTTP/1.0 ", false)]
+        public void IsHttp10_Success(string protocol, bool match)
+        {
+            Assert.Equal(match, HttpProtocol.IsHttp10(protocol));
+        }
+
+        public static TheoryData<Version, string> s_ValidData = new TheoryData<Version, string>
+        {
+            { new Version(3, 0), "HTTP/3" },
+            { new Version(2, 0), "HTTP/2" },
+            { new Version(1, 1), "HTTP/1.1" },
+            { new Version(1, 0), "HTTP/1.0" }
+        };
+
+        [Theory]
+        [MemberData(nameof(s_ValidData))]
+        public void GetHttpProtocol_CorrectIETFVersion(Version version, string expected)
+        {
+            var actual = HttpProtocol.GetHttpProtocol(version);
+
+            Assert.Equal(expected, actual);
+        }
+
+        public static TheoryData<Version> s_InvalidData = new TheoryData<Version>
+        {
+            { new Version(0, 3) },
+            { new Version(2, 1) }
+        };
+
+        [Theory]
+        [MemberData(nameof(s_InvalidData))]
+        public void GetHttpProtocol_ThrowErrorForUnknownVersion(Version version)
+        {
+            Assert.Throws<ArgumentOutOfRangeException>(() => HttpProtocol.GetHttpProtocol(version));
+        }
+    }
+}

src/Security/Authentication/Negotiate/src/NegotiateHandler.cs

@@ -57,7 +57,7 @@ public NegotiateHandler(IOptionsMonitor<NegotiateOptions> options, ILoggerFactor
         /// <returns></returns>
         protected override Task<object> CreateEventsAsync() => Task.FromResult<object>(new NegotiateEvents());
 
-        private bool IsHttp2 => string.Equals("HTTP/2", Request.Protocol, StringComparison.OrdinalIgnoreCase);
+        private bool IsSupportedProtocol => HttpProtocol.IsHttp11(Request.Protocol) || HttpProtocol.IsHttp10(Request.Protocol);
 
         /// <summary>
         /// Intercepts incomplete Negotiate authentication handshakes and continues or completes them.
@@ -80,10 +80,10 @@ public async Task<bool> HandleRequestAsync()
 
                 _requestProcessed = true;
 
-                if (IsHttp2)
+                if (!IsSupportedProtocol)
                 {
-                    // HTTP/2 is not supported. Do not throw because this may be running on a server that supports
-                    // both HTTP/1 and HTTP/2.
+                    // HTTP/1.0 and HTTP/1.1 are supported. Do not throw because this may be running on a server that supports
+                    // additional protocols.
                     return false;
                 }
 
@@ -291,7 +291,7 @@ protected override async Task<AuthenticateResult> HandleAuthenticateAsync()
                 throw new InvalidOperationException("AuthenticateAsync must not be called before the UseAuthentication middleware runs.");
             }
 
-            if (IsHttp2)
+            if (!IsSupportedProtocol)
             {
                 // Not supported. We don't throw because Negotiate may be set as the default auth
                 // handler on a server that's running HTTP/1 and HTTP/2. We'll challenge HTTP/2 requests

src/Servers/HttpSys/src/FeatureContext.cs

@@ -181,7 +181,7 @@ string IHttpRequestFeature.Protocol
             {
                 if (IsNotInitialized(Fields.Protocol))
                 {
-                    _httpProtocolVersion = Request.ProtocolVersion.GetHttpProtocolVersion();
+                    _httpProtocolVersion = HttpProtocol.GetHttpProtocol(Request.ProtocolVersion);
                     SetInitialized(Fields.Protocol);
                 }
                 return _httpProtocolVersion;

src/Servers/IIS/IIS/src/Core/IISHttpContext.FeatureCollection.cs

@@ -87,7 +87,7 @@ private void ExtraFeatureSet(Type key, object value)
 
         string IHttpRequestFeature.Protocol
         {
-            get => _httpProtocolVersion ??= HttpVersion.GetHttpProtocolVersion();
+            get => _httpProtocolVersion ??= HttpProtocol.GetHttpProtocol(HttpVersion);
             set => _httpProtocolVersion = value;
         }