Handle requests using absolute-form request URIs #1246

natemcmaster · 2016-12-05T22:40:58Z

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

cc @CesarBS @Tratcher

cesarblum · 2016-12-05T22:53:38Z

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

+                {
+                    // Request URIs can be in absolute form
+                    // See https://tools.ietf.org/html/rfc7230#section-5.3.2
+                    // This will skip over scheme and authority for determinie path, but preserving the vlues for rawTarget.


nits: determinie, vlues

cesarblum · 2016-12-05T22:57:47Z

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

+                    // an absolute URI is not required to end in a slash but must not be empty
+                    // see https://tools.ietf.org/html/rfc3986#section-4.3
+
+                    var pathIndex = scan.Seek(ByteForwardSlash, ByteSpace, ref end);


Seek returns -1 or the first byte it found with one of the specified values. The return value is not an index.

cesarblum · 2016-12-05T23:02:34Z

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


                consumed = scan;
                Method = method;
                QueryString = queryString;
-                RawTarget = rawTarget;
+                RawTarget = requestUriScheme + requestAuthority + rawUrlPath;


I think you'll see a perf hit from these concatenations. Ideally you should get the raw target in one go and set it here, instead of building it from it's parts.

Also, requestAuthority might be null, no?

requestUriScheme and requestAuthority will be null for most requests. Isn't concat with null a noop? Since the perf lab is down right now, I haven't been able to test if this incurs a significant perf hit or not.

Whoa, TIL. I thought you'd get a NullReferenceException when trying to concat a null.

cesarblum · 2016-12-05T23:04:28Z

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

+                    });
+                });
+
+            using (var host = builder.Build())


Use TestServer

cesarblum · 2016-12-05T23:04:35Z

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

+            {
+                host.Start();
+
+                using (var socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))


Use TestConnection

cesarblum · 2016-12-05T23:05:22Z

test/Microsoft.AspNetCore.Server.Kestrel.FunctionalTests/Utilities/TaskExtensions.cs

+
+namespace Microsoft.AspNetCore.Server.Kestrel.FunctionalTests
+{
+    public static class TaskExtensions


We already have this in https://github.com/aspnet/Testing/blob/dev/src/Microsoft.AspNetCore.Testing/TaskExtensions.cs

cesarblum · 2016-12-05T23:05:39Z

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

+        [InlineData("http://localhost", true, "")]
+        [InlineData("http://", false, null)]
+        [InlineData("https://", false, null)]
+        public async Task CanHandleRequestsWithUrlInAbsoluteForm(string requestUrl, bool valid, string expectedPath)


Add test cases for bad requests with malformed absolute URLs.

cesarblum · 2016-12-05T23:06:32Z

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Infrastructure/MemoryPoolIteratorExtensions.cs

+        /// <param name="knownScheme">A reference to the known scheme, if the input matches any</param>
+        /// <returns></returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool GetKnownUriScheme(this MemoryPoolIterator begin, out string knownScheme)


Add unit tests (look at existing tests for the other GetKnown* methods).

Tratcher · 2016-12-06T00:17:34Z

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

+                string requestAuthority = null;
+                if (scan.GetKnownUriScheme(out requestUriScheme))
+                {
+                    // Request URIs can be in absolute form


Tratcher · 2016-12-06T00:18:42Z

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

+                            Log.IsEnabled(LogLevel.Information) ? start.GetAsciiStringEscaped(end, MaxInvalidRequestLineChars) : string.Empty);
+                    }
+
+                    // TODO consider handling unicode host names


natemcmaster · 2016-12-06T00:30:56Z

🆙 📅

cesarblum · 2016-12-06T00:53:18Z

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

+                    var chNext = scan.Peek();
+                    if (chNext == ByteForwardSlash || chNext == ByteSpace)
+                    {
+                        // an absolute URI is not required to end in a slash but host must not be empty


Move this comment outside the if

cesarblum · 2016-12-06T00:56:49Z

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

@@ -428,59 +429,44 @@ public void CanUpgradeRequestWithConnectionKeepAliveUpgradeHeader()
        [InlineData("http://localhost/", true, "/")]
        [InlineData("https://localhost/", true, "/")]
        [InlineData("http://localhost", true, "")]
+        // bad requests


Write a separate test method for bad requests. Also, you can add those to the BadHttpRequestTests class.

cesarblum · 2016-12-06T00:57:01Z

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

-                              "Connection: close\r\n" +
-                              "\r\n";
+                    await connection.SendAll(
+                       $"GET {requestUrl} HTTP/1.1",


nit: indent

natemcmaster · 2016-12-06T01:28:08Z

This implementation ignores the authority section altogether, which means some malformed URI's could still be accepted. Is this okay? e.g. GET http://:80/abc HTTP/1.1 would be accepted.

Or do should we do a safe but slow System.Uri check to make sure the full URI is valid?

Tratcher · 2016-12-06T04:06:11Z

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

                begin = scan;
+
+                var targetIsAbsolute = false;
+                string requestUriScheme;


still not sure why you're creating these strings only to rebuild the rawTarget later. why not capture the full rawTarget all at once?

Will update

Tratcher · 2016-12-06T04:11:08Z

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Infrastructure/MemoryPoolIteratorExtensions.cs

+                return false;
+            }
+
+            if ((value & _mask7Chars) == _httpSchemeLong)


does the spec allow for ws:// or wss:// (WebSockets)?

Spec is ambiguous. It only says absolute-form = absolute-URI. Doesn't say anything about needing to ensure the scheme is http or https. What does websocket clients normally send?

RFC 6455 section 4.1 states that websockets clients are required to send the initial HTTP request using 'origin-form' (normal request format), not 'absolute-form'. I don't think we have a valid client scenario for a request like GET ws://host/path HTTP/1.1 so we're probably okay rejecting this format.

Technically it's not a valid client scenario to send absolute-form targets to the end-server, right? It's only meant to be sent to proxies AFAIK. I recall someone mentioning the spec requires that proxies change the target to origin-form, but end-servers still support absolute-form in case the proxy isn't compliant with the spec.

If we already going through this work to support buggy proxies, I think we should also allow ws/wss.

To make a distinction here, we support accepting absolute-form b/c the spec requires it and some http clients may send it. I'm in favor of rejecting anything with 'ws://' or 'wss:// because that is a buggy WebSockets client.

Tratcher · 2016-12-06T04:13:49Z

So long as we're not acting on the unvalidated values it should be fine.

cesarblum · 2016-12-06T15:59:45Z

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

+        [InlineData("GET http:// HTTP/1.1\r\n")]
+        [InlineData("GET https:// HTTP/1.1\r\n")]
+        [InlineData("GET http:/// HTTP/1.1\r\n")]
+        [InlineData("GET http://// HTTP/1.1\r\n")]


Add:

Not starting with http:// or https://

http

https

http:

https:/

http:/

https:/

http://<space>

https://<space>

http:// /

https:// /

cesarblum · 2016-12-06T16:00:18Z

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

+        [InlineData("HtTp:// ", false, null)]
+        [InlineData("https://", true, MemoryPoolIteratorExtensions.HttpsScheme)]
+        [InlineData("https://abc", true, MemoryPoolIteratorExtensions.HttpsScheme)]
+        public void GetKnownHttpSchema(string input, bool expectedResult, string expectedString)


nit: Gets

cesarblum · 2016-12-06T16:00:49Z

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

+        [InlineData("https://differenthost/abs/path", "/abs/path")] // handles mismatched hostname
+        [InlineData("http://localhost/", "/")]
+        [InlineData("https://localhost/", "/")]
+        [InlineData("http://localhost", "")]


If we decide things like http://:80 are ok, you should add it here.

Tratcher · 2016-12-06T20:39:09Z

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

@@ -52,12 +52,26 @@ public class BadHttpRequestTests
        [InlineData("} / HTTP/1.0\r\n")]


Is there a test somewhere for OPTIONS * HTTP/1.1? Path should be empty and RawTarget should be *.

Yes: KestrelTests.RequestTargetProcessingTests.NonPathRequestTargetSetInRawTarget.

cesarblum · 2016-12-07T00:15:28Z

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

+                if (targetBegin.Peek() != ByteForwardSlash)
+                {
+                    string requestUriScheme;
+                    if (scan.GetKnownHttpSchema(out requestUriScheme))


Given what we discussed, I don't think you need this method anymore - we're not really looking for any particular schemas, since we don't do anything about them. We do want to make sure it's a valid URI, otherwise we could just accept any kind of <garbage>/a/b/c, and that wouldn't make sense.

So here you could check if there isn't a /, like you're doing, and if there isn't this is the slow path and you grab the string from targetBegin to the slash and check if that's a valid URI (like you did below). Otherwise you're in the hot path and you should do things as before.

GetKnownHttpSchema skips an allocation for the Scheme string?

Yes, as Ben said, one goal was to minimize allocations.

Also, AFAIK there are no valid scenarios using absolute-form and schemes other than http:// andhttps://. Kestrel should reject requests like GET otherscheme://localhost/ HTTP/1.1 as invalid.

The scheme string wouldn't need to be allocated even if we supported unknown schema. The out parameter could be the length of the schema string since the schema from the target isn't stored anywhere.

Better yet, this could be like GetKnownVersion and advance the iterator itself. I see that GetKnownMethod doesn't advance the iterator. I would change that too for consistency.

halter73 · 2016-12-07T23:42:10Z

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

@@ -1021,8 +1025,34 @@ public RequestLineStatus TakeStartLine(SocketInput input)
                    scan.Skip(method.Length);
                }

-                scan.Take();
+                scan.Take(); // consume space


Nit: Put comment above line.

halter73 · 2016-12-07T23:44:43Z

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

+                        if (scan.Seek(ByteForwardSlash, ByteSpace, ref end) == -1)
+                        {
+                            RejectRequest(RequestRejectionReason.InvalidRequestLine,
+                               Log.IsEnabled(LogLevel.Information) ? start.GetAsciiStringEscaped(end, MaxInvalidRequestLineChars) : string.Empty);


Nit: Make a helper method for RejectRequest(RequestRejectionReason.InvalidRequestLine, startLineString) that takes the start and end iterators instead of a string so we don't see the ternary expression all over this method.

halter73 · 2016-12-07T23:49:37Z

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

@@ -1058,13 +1088,15 @@ public RequestLineStatus TakeStartLine(SocketInput input)

                var queryEnd = scan;

-                if (pathBegin.Peek() == ByteSpace)
+                if (pathBegin.Peek() == ByteSpace && targetBegin.Index == pathBegin.Index)


So what's the value of Path if the start line is GET http://www.example.org HTTP/1.1? string.Empty?

This seems weird since GET HTTP/1.1 is invalid. I think we should set Path to / or reject the request. Not sure which.

halter73 · 2016-12-07T23:50:07Z

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

-                scan.Take();
+                scan.Take(); // consume space
+
+                // begin consuming HTTP-version


I like the new comments. Same nit about them being on their own line.

halter73 · 2016-12-07T23:51:14Z

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

@@ -1103,7 +1135,7 @@ public RequestLineStatus TakeStartLine(SocketInput input)
                if (needDecode)
                {
                    // Read raw target before mutating memory.
-                    rawTarget = pathBegin.GetAsciiString(ref queryEnd);
+                    rawTarget = targetBegin.GetAsciiString(ref queryEnd);


What happens if there's a % in the host portion of the absolute target?

IIUC there RawTarget has always been the ASCII representation. Since we ignore the authority portion of the absolute-URI, we never bother to look for a %

% doesn't really apply to hosts anyways, they prefer punycode.

halter73 · 2016-12-07T23:59:50Z

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

                }
-                else if (rawTarget[0] == '/') // check rawTarget since normalizedTarget can be "" or "/" after dot segment removal
+                else if (requestUrlPath?.Length > 0 && requestUrlPath[0] == '/') // check requestUrlPath since normalizedUrlPath can be "" or "/" after dot segment removal


requestUrlPath can't be null, right? Like I mentioned in another comment, I don't like allowing requestUrlPath to ever be empty either.

I hadn't considered dot segment removal before though. I think if the dot segment removal ever causes the path to go past the root, e.g. /../, I would rather reject the request rather than set Path and QueryString to string.Empty.

halter73 · 2016-12-08T00:06:02Z

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Infrastructure/MemoryPoolIteratorExtensions.cs

+                return false;
+            }
+
+            if ((value & _mask7Chars) == _httpSchemeLong)


Technically it's not a valid client scenario to send absolute-form targets to the end-server, right? It's only meant to be sent to proxies AFAIK. I recall someone mentioning the spec requires that proxies change the target to origin-form, but end-servers still support absolute-form in case the proxy isn't compliant with the spec.

If we already going through this work to support buggy proxies, I think we should also allow ws/wss.

halter73 · 2016-12-08T00:07:25Z

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

+        [InlineData("http://[email protected]/path", "/path")]
+        [InlineData("http://root:[email protected]/path", "/path")]
+        [InlineData("https://localhost/", "/")]
+        [InlineData("http://localhost", "")]


Nice that you added a test for this. Don't like the result 😛

Agreed, path should not be empty. reject or set it to /

I'm favor of keeping it and setting to "/". The HTTP spec says is absolute-form = absolute-URI, and absolute URI's don't require the trailing slash.

halter73 · 2016-12-08T00:11:42Z

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

+                if (targetBegin.Peek() != ByteForwardSlash)
+                {
+                    string requestUriScheme;
+                    if (scan.GetKnownHttpSchema(out requestUriScheme))


The scheme string wouldn't need to be allocated even if we supported unknown schema. The out parameter could be the length of the schema string since the schema from the target isn't stored anywhere.

Better yet, this could be like GetKnownVersion and advance the iterator itself. I see that GetKnownMethod doesn't advance the iterator. I would change that too for consistency.

cesarblum · 2016-12-10T00:18:37Z

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

+                        }
+
+                        begin = scan;
+                    }


else reject.

Actually, we don't want to reject yet. e.g. 'asterisk-form'. is still okay.

cesarblum

A few nits and some comments on tests. After that and TODOs we're good to go.

cesarblum · 2017-01-05T17:11:07Z

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

+                        // Start-line can contain uri in absolute form. e.g. 'GET http://contoso.com/favicon.ico HTTP/1.1'
+                        // Clients should only send this to proxies, but the spec requires we handle it anyways.
+                        // cref https://tools.ietf.org/html/rfc7230#section-5.3
+


nit: remove this blank line

cesarblum · 2017-01-05T17:18:58Z

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

+                    // validation of absolute-form URI may be slow, but clients
+                    // should not be sending this form anyways, so perf optimization 
+                    // not high priority
+


nit: remove this blank line

cesarblum · 2017-01-05T17:23:06Z

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

+        [InlineData("http://localhost", "/")]
+        [InlineData("http://127.0.0.1/", "/")]
+        [InlineData("http://[::1]/", "/")]
+        [InlineData("http://[::1]:8080/", "/")]


Add cases with:

Query string

Percent encoding

Both

cesarblum · 2017-01-05T17:25:46Z

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

+            {
+                using (var connection = server.CreateConnection())
+                {
+                    await connection.SendAll(


cesarblum · 2017-01-05T17:26:10Z

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

+                        "Host: localhost",
+                        "",
+                        "");
+


connection.Receive expected response

cesarblum · 2017-01-05T17:28:06Z

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

+        [InlineData("GET / / HTTP/1.1\r\n")]
+        [InlineData("GET http://  HTTP/1.1\r\n")]
+        [InlineData("GET https://  HTTP/1.1\r\n")]
+        [InlineData("GET https:// / HTTP/1.1\r\n")]


Why are these here? The version is valid in the new test cases.

These are here because there is a space or a slash where the HTTP version should begin.

cesarblum · 2017-01-05T17:28:51Z

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

+        [InlineData("http://[::1]", "/")]
+        [InlineData("http://[::1]/path", "/path")]
+        [InlineData("http://[::1]:8080/", "/")]
+        [InlineData("http://user@[::1]:8080/", "/")]


Add cases with query string and percent encoding here too.

Did you miss this one?

cesarblum · 2017-01-05T17:29:23Z

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

+        [InlineData("http://abc", true, MemoryPoolIteratorExtensions.HttpScheme)]
+        [InlineData("http:// ", true, MemoryPoolIteratorExtensions.HttpScheme)]
+        [InlineData("http:/  ", false, null)]
+        [InlineData("HtTp:// ", false, null)]


Add wrong casing tests for https too.

cesarblum · 2017-01-05T17:31:12Z

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

+        [InlineData("http:/  ", false, null)]
+        [InlineData("HtTp:// ", false, null)]
+        [InlineData("https://", true, MemoryPoolIteratorExtensions.HttpsScheme)]
+        [InlineData("https://abc", true, MemoryPoolIteratorExtensions.HttpsScheme)]


Test same conditions on http and https. You're not testing https:/ nor followed by space.

For both: http: and https:

natemcmaster · 2017-01-06T18:39:45Z

🆙 📅

halter73 · 2017-01-06T23:27:57Z

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Infrastructure/MemoryPoolIteratorExtensions.cs

+            if ((value & _mask7Chars) == _httpSchemeLong)
+            {
+                knownScheme = HttpScheme;
+                begin.Skip(knownScheme.Length);


Is this doing anything? Isn't begin a copied struct that isn't used at all afterwards?

halter73 · 2017-01-06T23:28:25Z

src/Microsoft.AspNetCore.Server.Kestrel/Internal/Infrastructure/MemoryPoolIteratorExtensions.cs

+        /// <param name="knownScheme">A reference to the known scheme, if the input matches any</param>
+        /// <returns>True when memory starts with known http or https schema</returns>
+        [MethodImpl(MethodImplOptions.AggressiveInlining)]
+        public static bool GetKnownHttpSchema(this MemoryPoolIterator begin, out string knownScheme)


Is the out parameter ever used? Would HasKnownHttpSchema be better?

Yes the out param is used.

halter73 · 2017-01-06T23:33:23Z

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

+        // TODO invalidate requests that don't meet the HTTP spec. See https://github.com/aspnet/KestrelHttpServer/issues/1279
+        //[InlineData("GET otherscheme://host/ HTTP/1.1\r\n")]
+        //[InlineData("GET ws://host/ HTTP/1.1\r\n")]
+        //[InlineData("GET wss://host/ HTTP/1.1\r\n")]


If there is an absolute-form request with a non HTTP(S) scheme, does Path become string.Empty since it doesn't start with '/' while not being rejected?

natemcmaster · 2017-01-07T03:52:48Z

Currently, yes. That is the behavior, and was I opened #1279 to address.

natemcmaster · 2017-01-07T03:56:30Z

Yeah this can be removed. This method can be HasKnownHttpMethod instead, but we still need an out param to get the length that should be skipped. Will update the PR

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

cesarblum · 2017-01-10T18:07:21Z

@natemcmaster Can't you skip inside the method itself?

natemcmaster · 2017-01-10T20:11:40Z

cc @pakrym this probably overlaps with work you are doing. Ok if I put this in before? Or would it be better to hold off?

natemcmaster · 2017-01-11T01:21:45Z

In person discussion. Closing this for now as we expect large merge conflicts with work @pakrym is doing, and fixing the bug that this PR addresses is lower priority. We'll come back to this before 2.0.0, after @pakrym's refactorings.

dnfclas added the cla-already-signed label Dec 5, 2016

cesarblum suggested changes Dec 5, 2016

View reviewed changes

Tratcher reviewed Dec 6, 2016

View reviewed changes

cesarblum suggested changes Dec 6, 2016

View reviewed changes

Tratcher reviewed Dec 6, 2016

View reviewed changes

cesarblum suggested changes Dec 6, 2016

View reviewed changes

Tratcher reviewed Dec 6, 2016

View reviewed changes

cesarblum suggested changes Dec 7, 2016

View reviewed changes

halter73 suggested changes Dec 8, 2016

View reviewed changes

cesarblum suggested changes Dec 10, 2016

View reviewed changes

natemcmaster force-pushed the namc/fix666 branch from aaf80e7 to 68b914c Compare January 3, 2017 22:59

cesarblum suggested changes Jan 5, 2017

View reviewed changes

halter73 reviewed Jan 6, 2017

View reviewed changes

natemcmaster force-pushed the namc/fix666 branch from f84d50d to 5b1d778 Compare January 9, 2017 19:32

Added more frame tests

6ef9877

natemcmaster closed this Jan 11, 2017

natemcmaster mentioned this pull request Mar 9, 2017

Handle absolute, asterisk, and authority-form request targets #1470

Merged

natemcmaster deleted the namc/fix666 branch March 13, 2017 19:11

		@@ -52,12 +52,26 @@ public class BadHttpRequestTests
		[InlineData("} / HTTP/1.0\r\n")]

Handle requests using absolute-form request URIs #1246

Handle requests using absolute-form request URIs #1246

Uh oh!

Conversation

natemcmaster commented Dec 5, 2016

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

natemcmaster commented Dec 6, 2016

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

natemcmaster commented Dec 6, 2016

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Tratcher commented Dec 6, 2016

Uh oh!

cesarblum Dec 6, 2016 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

cesarblum Dec 6, 2016 •

edited

Loading