Handle requests using absolute-form request URIs.

An absolute-form request URI has a start line in form: "GET http://host/path HTTP/1.1".
RFC 7230 section 5.3.2 stipulates that servers should allow absolute-form request URIs.

This change will handles requests using absolute-form. The scheme and authority
section of the absolute URI are ignored, but will still appear in IHttpRequestFeature.RawTarget.

Resolves #666

Author: Nate McMaster

test/Microsoft.AspNetCore.Server.Kestrel.FunctionalTests/RequestTests.cs

@@ -454,6 +454,72 @@ public async Task RequestAbortedTokenFiredOnClientFIN()
             }
         }
 
+        [Theory]
+        [InlineData("http://localhost/abs/path", "/abs/path", null)]
+        [InlineData("https://localhost/abs/path", "/abs/path", null)] // handles mismatch scheme
+        [InlineData("https://localhost:22/abs/path", "/abs/path", null)] // handles mismatched ports
+        [InlineData("https://differenthost/abs/path", "/abs/path", null)] // handles mismatched hostname
+        [InlineData("http://localhost/", "/", null)]
+        [InlineData("http://[email protected]/path", "/path", null)]
+        [InlineData("http://root:[email protected]/path", "/path", null)]
+        [InlineData("https://localhost/", "/", null)]
+        [InlineData("http://localhost", "/", null)]
+        [InlineData("http://127.0.0.1/", "/", null)]
+        [InlineData("http://[::1]/", "/", null)]
+        [InlineData("http://[::1]:8080/", "/", null)]
+        [InlineData("http://localhost?q=123&w=xyz", "/", "123")]
+        [InlineData("http://localhost/?q=123&w=xyz", "/", "123")]
+        [InlineData("http://localhost/path?q=123&w=xyz", "/path", "123")]
+        [InlineData("http://localhost/path%20with%20space?q=abc%20123", "/path with space", "abc 123")]
+        public async Task CanHandleRequestsWithUrlInAbsoluteForm(string requestUrl, string expectedPath, string queryValue)
+        {
+            var pathTcs = new TaskCompletionSource<PathString>();
+            var rawTargetTcs = new TaskCompletionSource<string>();
+            var hostTcs = new TaskCompletionSource<HostString>();
+            var queryTcs = new TaskCompletionSource<IQueryCollection>();
+
+            using (var server = new TestServer(async context =>
+                 {
+                     pathTcs.TrySetResult(context.Request.Path);
+                     hostTcs.TrySetResult(context.Request.Host);
+                     queryTcs.TrySetResult(context.Request.Query);
+                     rawTargetTcs.TrySetResult(context.Features.Get<IHttpRequestFeature>().RawTarget);
+                     await context.Response.WriteAsync("Done");
+                 }))
+            {
+                using (var connection = server.CreateConnection())
+                {
+                    await connection.Send(
+                        $"GET {requestUrl} HTTP/1.1",
+                        "Content-Length: 0",
+                        "Host: localhost",
+                        "",
+                        "");
+
+                    await connection.Receive($"HTTP/1.1 200 OK",
+                        $"Date: {server.Context.DateHeaderValue}",
+                        "Transfer-Encoding: chunked",
+                        "",
+                        "4",
+                        "Done")
+                        .TimeoutAfter(TimeSpan.FromSeconds(10));
+
+                    await Task.WhenAll(pathTcs.Task, rawTargetTcs.Task, hostTcs.Task, queryTcs.Task).TimeoutAfter(TimeSpan.FromSeconds(30));
+                    Assert.Equal(new PathString(expectedPath), pathTcs.Task.Result);
+                    Assert.Equal(requestUrl, rawTargetTcs.Task.Result);
+                    Assert.Equal("localhost", hostTcs.Task.Result.ToString());
+                    if (queryValue == null)
+                    {
+                        Assert.False(queryTcs.Task.Result.ContainsKey("q"));
+                    }
+                    else
+                    {
+                        Assert.Equal(queryValue, queryTcs.Task.Result["q"]);
+                    }
+                }
+            }
+        }
+
         private async Task TestRemoteIPAddress(string registerAddress, string requestAddress, string expectAddress)
         {
             var builder = new WebHostBuilder()

test/Microsoft.AspNetCore.Server.KestrelTests/FrameTests.cs

@@ -477,6 +477,35 @@ public async Task TakeStartLineReturnsWhenGivenIncompleteRequestLines(string req
             Assert.False(returnValue);
         }
 
+        [Theory]
+        [InlineData("http://host/abs/path", "/abs/path")]
+        [InlineData("https://host/abs/path", "/abs/path")]
+        [InlineData("https://host:22/abs/path", "/abs/path")]
+        [InlineData("https://user@host:9080/abs/path", "/abs/path")]
+        [InlineData("http://host/", "/")]
+        [InlineData("https://host/", "/")]
+        [InlineData("http://host", "/")]
+        [InlineData("http://user@host/", "/")]
+        [InlineData("http://127.0.0.1/", "/")]
+        [InlineData("http://[email protected]/", "/")]
+        [InlineData("http://[email protected]:8080/", "/")]
+        [InlineData("http://127.0.0.1:8080/", "/")]
+        [InlineData("http://[::1]", "/")]
+        [InlineData("http://[::1]/path", "/path")]
+        [InlineData("http://[::1]:8080/", "/")]
+        [InlineData("http://user@[::1]:8080/", "/")]
+        public void TakeStartLineHandlesRequestTarget(string rawTarget, string expectedPath)
+        {
+            var firstLine = Encoding.ASCII.GetBytes($"GET {rawTarget} HTTP/1.1\r\n");
+            _socketInput.IncomingData(firstLine, 0, firstLine.Length);
+
+            var status = _frame.TakeStartLine(_socketInput);
+
+            Assert.Equal(Frame.RequestLineStatus.Done, status);
+            Assert.Equal(expectedPath, _frame.Path);
+            Assert.Equal(rawTarget, _frame.RawTarget);
+        }
+
         [Fact]
         public async Task ParseRequestStartsRequestHeadersTimeoutOnFirstByteAvailable()
         {