Merge pull request #657 from justcoding121/master

honfika · web-flow · commit 94e3df950e02 · 2019-11-16T21:50:32.000+01:00
fixes
diff --git a/src/Titanium.Web.Proxy/Compression/CompressionUtil.cs b/src/Titanium.Web.Proxy/Compression/CompressionUtil.cs
@@ -7,13 +7,13 @@ internal static class CompressionUtil
     {
         public static HttpCompression CompressionNameToEnum(string name)
         {
-            if (KnownHeaders.ContentEncodingGzip.Equals(name.AsSpan()))
+            if (KnownHeaders.ContentEncodingGzip.Equals(name))
                 return HttpCompression.Gzip;
 
-            if (KnownHeaders.ContentEncodingDeflate.Equals(name.AsSpan()))
+            if (KnownHeaders.ContentEncodingDeflate.Equals(name))
                 return HttpCompression.Deflate;
 
-            if (KnownHeaders.ContentEncodingBrotli.Equals(name.AsSpan()))
+            if (KnownHeaders.ContentEncodingBrotli.Equals(name))
                 return HttpCompression.Brotli;
 
             return HttpCompression.Unsupported;
diff --git a/src/Titanium.Web.Proxy/ExplicitClientHandler.cs b/src/Titanium.Web.Proxy/ExplicitClientHandler.cs
@@ -47,7 +47,6 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
 
             try
             {
-                string? connectHostname = null;
                 TunnelConnectSessionEventArgs? connectArgs = null;
                 
                 // Client wants to create a secure tcp tunnel (probably its a HTTPS or Websocket request)
@@ -62,14 +61,7 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
 
                     Request.ParseRequestLine(httpCmd!, out string _, out string httpUrl, out var version);
 
-                    connectHostname = httpUrl;
-                    int idx = connectHostname.IndexOf(":");
-                    if (idx >= 0)
-                    {
-                        connectHostname = connectHostname.Substring(0, idx);
-                    }
-
-                    var connectRequest = new ConnectRequest(connectHostname)
+                    var connectRequest = new ConnectRequest(httpUrl)
                     {
                         OriginalUrlData = HttpHeader.Encoding.GetBytes(httpUrl),
                         HttpVersion = version
@@ -130,7 +122,7 @@ await clientStreamWriter.WriteResponseAsync(connectArgs.HttpClient.Response,
                     bool isClientHello = clientHelloInfo != null;
                     if (clientHelloInfo != null)
                     {
-                        connectRequest.Scheme = ProxyServer.UriSchemeHttps;
+                        connectRequest.IsHttps = true;
                         connectRequest.TunnelType = TunnelType.Https;
                         connectRequest.ClientHelloInfo = clientHelloInfo;
                     }
@@ -186,6 +178,13 @@ await clientStreamWriter.WriteResponseAsync(connectArgs.HttpClient.Response,
                             }
                         }
 
+                        string connectHostname = httpUrl;
+                        int idx = connectHostname.IndexOf(":");
+                        if (idx >= 0)
+                        {
+                            connectHostname = connectHostname.Substring(0, idx);
+                        }
+
                         X509Certificate2? certificate = null;
                         try
                         {
diff --git a/src/Titanium.Web.Proxy/Http/ConnectRequest.cs b/src/Titanium.Web.Proxy/Http/ConnectRequest.cs
@@ -9,10 +9,10 @@ namespace Titanium.Web.Proxy.Http
     /// </summary>
     public class ConnectRequest : Request
     {
-        public ConnectRequest(string hostname)
+        public ConnectRequest(string authority)
         {
             Method = "CONNECT";
-            Hostname = hostname;
+            Authority = authority;
         }
 
         public TunnelType TunnelType { get; internal set; }
diff --git a/src/Titanium.Web.Proxy/Http/HttpWebClient.cs b/src/Titanium.Web.Proxy/Http/HttpWebClient.cs
@@ -121,6 +121,10 @@ internal async Task SendRequest(bool enable100ContinueBehaviour, bool isTranspar
             else
             {
                 url = Request.RequestUri.GetOriginalPathAndQuery();
+                if (url == string.Empty)
+                {
+                    url = "/";
+                }
             }
 
             var headerBuilder = new HeaderBuilder();
diff --git a/src/Titanium.Web.Proxy/Http/Request.cs b/src/Titanium.Web.Proxy/Http/Request.cs
@@ -22,10 +22,10 @@ public class Request : RequestResponseBase
         /// <summary>
         ///     Is Https?
         /// </summary>
-        public bool IsHttps => RequestUri.Scheme == ProxyServer.UriSchemeHttps;
+        public bool IsHttps { get; internal set; }
 
         private ByteString originalUrlData;
-        private protected ByteString UrlData;
+        private ByteString urlData;
 
         internal ByteString OriginalUrlData
         {
@@ -37,9 +37,21 @@ internal ByteString OriginalUrlData
             }
         }
 
-        internal string Scheme { get; set; } = ProxyServer.UriSchemeHttp;
+        private protected ByteString UrlData
+        {
+            get => urlData;
+            set
+            {
+                urlData = value;
+                var scheme = getUriScheme(UrlData);
+                if (scheme.Length > 0)
+                {
+                    IsHttps = scheme.Equals(ProxyServer.UriSchemeHttps8);
+                }
+            }
+        }
 
-        internal string? Hostname { get; set; }
+        internal string? Authority { get; set; }
 
         /// <summary>
         ///     The original request Url.
@@ -53,21 +65,21 @@ public Uri RequestUri
         {
             get
             {
-                string url;
-                if (startsWithUriScheme(UrlData))
-                {
-                    url = UrlData.GetString();
-                }
-                else
+                string url = UrlData.GetString();
+                if (getUriScheme(UrlData).Length == 0)
                 {
-                    string? host = Host ?? Hostname;
-                    string? hostAndPath = host;
-                    if (UrlData.Length > 0 && UrlData[0] == '/')
+                    string? hostAndPath = Host ?? Authority;
+
+                    if (url.StartsWith("/"))
+                    {
+                        hostAndPath += url;
+                    }
+                    else
                     {
-                        hostAndPath += UrlData.GetString();
+                        //throw new Exception($"Invalid URL: '{url}'");
                     }
 
-                    url = string.Concat(Scheme == ProxyServer.UriSchemeHttps ? "https://" : "http://", hostAndPath);
+                    url = string.Concat(IsHttps ? "https://" : "http://", hostAndPath);
                 }
 
                 try
@@ -87,7 +99,16 @@ public Uri RequestUri
         public string Url
         {
             get => UrlData.GetString();
-            set => UrlData = value.GetByteString();
+            set
+            {
+                UrlData = value.GetByteString();
+
+                if (Host != null)
+                {
+                    var uri = new Uri(value);
+                    Host = uri.Authority;
+                }
+            }
         }
 
         [Obsolete("This property is obsolete. Use Url property instead")]
@@ -147,7 +168,7 @@ public bool ExpectContinue
             get
             {
                 string? headerValue = Headers.GetHeaderValueOrNull(KnownHeaders.Expect);
-                return headerValue != null && headerValue.Equals(KnownHeaders.Expect100Continue);
+                return KnownHeaders.Expect100Continue.Equals(headerValue);
             }
         }
 
@@ -290,11 +311,11 @@ private static bool isAllUpper(string input)
             return true;
         }
 
-        private bool startsWithUriScheme(ByteString str)
+        private ByteString getUriScheme(ByteString str)
         {
             if (str.Length < 3)
             {
-                return false;
+                return ByteString.Empty;
             }
 
             // regex: "^[a-z]*://"
@@ -310,26 +331,26 @@ private bool startsWithUriScheme(ByteString str)
 
                 if (ch < 'A' || ch > 'z' || (ch > 'Z' && ch < 'a')) // ASCII letter
                 {
-                    return false;
+                    return ByteString.Empty;
                 }
             }
 
             if (str[i++] != ':')
             {
-                return false;
+                return ByteString.Empty;
             }
 
             if (str[i++] != '/')
             {
-                return false;
+                return ByteString.Empty;
             }
 
             if (str[i] != '/')
             {
-                return false;
+                return ByteString.Empty;
             }
 
-            return true;
+            return new ByteString(str.Data.Slice(0, i - 2));
         }
     }
 }
diff --git a/src/Titanium.Web.Proxy/Http2/Http2Helper.cs b/src/Titanium.Web.Proxy/Http2/Http2Helper.cs
@@ -263,9 +263,9 @@ private static async Task copyHttp2FrameAsync(Stream input, Stream output,
 
                             request.HttpVersion = HttpVersion.Version20;
                             request.Method = method.GetString();
+                            request.IsHttps = headerListener.Scheme == ProxyServer.UriSchemeHttps;
+                            request.Authority = headerListener.Authority.GetString();
                             request.OriginalUrlData = path;
-                            request.Scheme = headerListener.Scheme;
-                            request.Hostname = headerListener.Authority.GetString();
 
                             //request.RequestUri = headerListener.GetUri();
                         }
@@ -468,9 +468,10 @@ private static async Task sendHeader(Http2Settings settings, Http2FrameHeader fr
 
             if (rr is Request request)
             {
+                var uri = request.RequestUri;
                 encoder.EncodeHeader(writer, StaticTable.KnownHeaderMethod, request.Method.GetByteString());
-                encoder.EncodeHeader(writer, StaticTable.KnownHeaderAuhtority, request.RequestUri.Host.GetByteString());
-                encoder.EncodeHeader(writer, StaticTable.KnownHeaderScheme, request.RequestUri.Scheme.GetByteString());
+                encoder.EncodeHeader(writer, StaticTable.KnownHeaderAuhtority, uri.Authority.GetByteString());
+                encoder.EncodeHeader(writer, StaticTable.KnownHeaderScheme, uri.Scheme.GetByteString());
                 encoder.EncodeHeader(writer, StaticTable.KnownHeaderPath, request.Url.GetByteString(), false,
                     HpackUtil.IndexType.None, false);
             }
@@ -572,10 +573,6 @@ class Http2Settings
 
         class MyHeaderListener : IHeaderListener
         {
-            private static ByteString SchemeHttp = (ByteString)ProxyServer.UriSchemeHttp;
-
-            private static ByteString SchemeHttps = (ByteString)ProxyServer.UriSchemeHttps;
-
             private readonly Action<ByteString, ByteString> addHeaderFunc;
 
             public ByteString Method { get; private set; }
@@ -592,12 +589,12 @@ public string Scheme
             {
                 get
                 {
-                    if (scheme.Equals(SchemeHttp))
+                    if (scheme.Equals(ProxyServer.UriSchemeHttp8))
                     {
                         return ProxyServer.UriSchemeHttp;
                     }
 
-                    if (scheme.Equals(SchemeHttps))
+                    if (scheme.Equals(ProxyServer.UriSchemeHttps8))
                     {
                         return ProxyServer.UriSchemeHttps;
                     }
diff --git a/src/Titanium.Web.Proxy/Models/ExplicitProxyEndPoint.cs b/src/Titanium.Web.Proxy/Models/ExplicitProxyEndPoint.cs
@@ -1,4 +1,5 @@
-﻿using System.Net;
+﻿using System.Diagnostics;
+using System.Net;
 using System.Threading.Tasks;
 using Titanium.Web.Proxy.EventArguments;
 using Titanium.Web.Proxy.Extensions;
@@ -9,6 +10,7 @@ namespace Titanium.Web.Proxy.Models
     ///     A proxy endpoint that the client is aware of.
     ///     So client application know that it is communicating with a proxy server.
     /// </summary>
+    [DebuggerDisplay("Explicit: {IpAddress}:{Port}")]
     public class ExplicitProxyEndPoint : ProxyEndPoint
     {
         /// <summary>
diff --git a/src/Titanium.Web.Proxy/Models/TransparentProxyEndPoint.cs b/src/Titanium.Web.Proxy/Models/TransparentProxyEndPoint.cs
@@ -1,4 +1,5 @@
-﻿using System.Net;
+﻿using System.Diagnostics;
+using System.Net;
 using System.Threading.Tasks;
 using Titanium.Web.Proxy.EventArguments;
 using Titanium.Web.Proxy.Extensions;
@@ -9,6 +10,7 @@ namespace Titanium.Web.Proxy.Models
     ///     A proxy end point client is not aware of.
     ///     Useful when requests are redirected to this proxy end point through port forwarding via router.
     /// </summary>
+    [DebuggerDisplay("Explicit: {IpAddress}:{Port}")]
     public class TransparentProxyEndPoint : ProxyEndPoint
     {
         /// <summary>
diff --git a/src/Titanium.Web.Proxy/Network/Tcp/TcpConnectionFactory.cs b/src/Titanium.Web.Proxy/Network/Tcp/TcpConnectionFactory.cs
@@ -125,9 +125,10 @@ internal async Task<string> GetConnectionCacheKey(ProxyServer server, SessionEve
 
             session.CustomUpStreamProxyUsed = customUpStreamProxy;
 
+            var uri = session.HttpClient.Request.RequestUri;
             return GetConnectionCacheKey(
-                session.HttpClient.Request.RequestUri.Host,
-                session.HttpClient.Request.RequestUri.Port,
+                uri.Host,
+                uri.Port,
                 isHttps, applicationProtocols,
                 session.HttpClient.UpStreamEndPoint ?? server.UpStreamEndPoint,
                 customUpStreamProxy ?? (isHttps ? server.UpStreamHttpsProxy : server.UpStreamHttpProxy));
@@ -179,9 +180,10 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer server,
 
             session.CustomUpStreamProxyUsed = customUpStreamProxy;
 
+            var uri = session.HttpClient.Request.RequestUri;
             return await GetServerConnection(
-                session.HttpClient.Request.RequestUri.Host,
-                session.HttpClient.Request.RequestUri.Port,
+                uri.Host,
+                uri.Port,
                 session.HttpClient.Request.HttpVersion,
                 isHttps, applicationProtocols, isConnect,
                 server, session, session.HttpClient.UpStreamEndPoint ?? server.UpStreamEndPoint,
@@ -372,9 +374,11 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost
                 if (useUpstreamProxy && (isConnect || isHttps))
                 {
                     var writer = new HttpRequestWriter(stream, proxyServer.BufferPool);
-                    var connectRequest = new ConnectRequest(remoteHostName)
+                    string authority = $"{remoteHostName}:{remotePort}";
+                    var connectRequest = new ConnectRequest(authority)
                     {
-                        OriginalUrlData = HttpHeader.Encoding.GetBytes($"{remoteHostName}:{remotePort}"),
+                        IsHttps = isHttps,
+                        OriginalUrlData = HttpHeader.Encoding.GetBytes(authority),
                         HttpVersion = httpVersion
                     };
 
diff --git a/src/Titanium.Web.Proxy/ProxyServer.cs b/src/Titanium.Web.Proxy/ProxyServer.cs
@@ -32,6 +32,10 @@ public partial class ProxyServer : IDisposable
         internal static readonly string UriSchemeHttp = Uri.UriSchemeHttp;
         internal static readonly string UriSchemeHttps = Uri.UriSchemeHttps;
 
+        internal static ByteString UriSchemeHttp8 = (ByteString)UriSchemeHttp;
+        internal static ByteString UriSchemeHttps8 = (ByteString)UriSchemeHttps;
+
+
         /// <summary>
         ///     A default exception log func.
         /// </summary>
diff --git a/src/Titanium.Web.Proxy/RequestHandler.cs b/src/Titanium.Web.Proxy/RequestHandler.cs
@@ -84,8 +84,8 @@ await HeaderParser.ReadHeaders(clientStream, args.HttpClient.Request.Headers,
                             var request = args.HttpClient.Request;
                             if (connectRequest != null)
                             {
-                                request.Scheme = connectRequest.Scheme;
-                                request.Hostname = connectRequest.Hostname;
+                                request.IsHttps = connectRequest.IsHttps;
+                                request.Authority = connectRequest.Authority;
                             }
 
                             request.OriginalUrlData = HttpHeader.Encoding.GetBytes(httpUrl);
diff --git a/tests/Titanium.Web.Proxy.IntegrationTests/Helpers/HttpContinueClient.cs b/tests/Titanium.Web.Proxy.IntegrationTests/Helpers/HttpContinueClient.cs
@@ -34,7 +34,7 @@ public async Task<Response> Post(string server, int port, string content)
 
             var buffer = new byte[1024];
             var responseMsg = string.Empty;
-            Response response = null;
+            Response response;
 
             while ((response = HttpMessageParsing.ParseResponse(responseMsg)) == null)
             {

Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,13 @@ internal static class CompressionUtil`
`7`	`7`	`{`
`8`	`8`	`public static HttpCompression CompressionNameToEnum(string name)`
`9`	`9`	`{`
`10`		`- if (KnownHeaders.ContentEncodingGzip.Equals(name.AsSpan()))`
	`10`	`+ if (KnownHeaders.ContentEncodingGzip.Equals(name))`
`11`	`11`	`return HttpCompression.Gzip;`
`12`	`12`
`13`		`- if (KnownHeaders.ContentEncodingDeflate.Equals(name.AsSpan()))`
	`13`	`+ if (KnownHeaders.ContentEncodingDeflate.Equals(name))`
`14`	`14`	`return HttpCompression.Deflate;`
`15`	`15`
`16`		`- if (KnownHeaders.ContentEncodingBrotli.Equals(name.AsSpan()))`
	`16`	`+ if (KnownHeaders.ContentEncodingBrotli.Equals(name))`
`17`	`17`	`return HttpCompression.Brotli;`
`18`	`18`
`19`	`19`	`return HttpCompression.Unsupported;`
Original file line number	Diff line number	Diff line change
`@@ -47,7 +47,6 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect`
`47`	`47`
`48`	`48`	`try`
`49`	`49`	`{`
`50`		`- string? connectHostname = null;`
`51`	`50`	`TunnelConnectSessionEventArgs? connectArgs = null;`
`52`	`51`
`53`	`52`	`// Client wants to create a secure tcp tunnel (probably its a HTTPS or Websocket request)`
`@@ -62,14 +61,7 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect`
`62`	`61`
`63`	`62`	`Request.ParseRequestLine(httpCmd!, out string _, out string httpUrl, out var version);`
`64`	`63`
`65`		`- connectHostname = httpUrl;`
`66`		`- int idx = connectHostname.IndexOf(":");`
`67`		`- if (idx >= 0)`
`68`		`- {`
`69`		`- connectHostname = connectHostname.Substring(0, idx);`
`70`		`- }`
`71`		`-`
`72`		`- var connectRequest = new ConnectRequest(connectHostname)`
	`64`	`+ var connectRequest = new ConnectRequest(httpUrl)`
`73`	`65`	`{`
`74`	`66`	`OriginalUrlData = HttpHeader.Encoding.GetBytes(httpUrl),`
`75`	`67`	`HttpVersion = version`
`@@ -130,7 +122,7 @@ await clientStreamWriter.WriteResponseAsync(connectArgs.HttpClient.Response,`
`130`	`122`	`bool isClientHello = clientHelloInfo != null;`
`131`	`123`	`if (clientHelloInfo != null)`
`132`	`124`	`{`
`133`		`- connectRequest.Scheme = ProxyServer.UriSchemeHttps;`
	`125`	`+ connectRequest.IsHttps = true;`
`134`	`126`	`connectRequest.TunnelType = TunnelType.Https;`
`135`	`127`	`connectRequest.ClientHelloInfo = clientHelloInfo;`
`136`	`128`	`}`
`@@ -186,6 +178,13 @@ await clientStreamWriter.WriteResponseAsync(connectArgs.HttpClient.Response,`
`186`	`178`	`}`
`187`	`179`	`}`
`188`	`180`
	`181`	`+ string connectHostname = httpUrl;`
	`182`	`+ int idx = connectHostname.IndexOf(":");`
	`183`	`+ if (idx >= 0)`
	`184`	`+ {`
	`185`	`+ connectHostname = connectHostname.Substring(0, idx);`
	`186`	`+ }`
	`187`	`+`
`189`	`188`	`X509Certificate2? certificate = null;`
`190`	`189`	`try`
`191`	`190`	`{`
Original file line number	Diff line number	Diff line change
`@@ -9,10 +9,10 @@ namespace Titanium.Web.Proxy.Http`
`9`	`9`	`/// </summary>`
`10`	`10`	`public class ConnectRequest : Request`
`11`	`11`	`{`
`12`		`- public ConnectRequest(string hostname)`
	`12`	`+ public ConnectRequest(string authority)`
`13`	`13`	`{`
`14`	`14`	`Method = "CONNECT";`
`15`		`- Hostname = hostname;`
	`15`	`+ Authority = authority;`
`16`	`16`	`}`
`17`	`17`
`18`	`18`	`public TunnelType TunnelType { get; internal set; }`
Original file line number	Diff line number	Diff line change
`@@ -121,6 +121,10 @@ internal async Task SendRequest(bool enable100ContinueBehaviour, bool isTranspar`
`121`	`121`	`else`
`122`	`122`	`{`
`123`	`123`	`url = Request.RequestUri.GetOriginalPathAndQuery();`
	`124`	`+ if (url == string.Empty)`
	`125`	`+ {`
	`126`	`+ url = "/";`
	`127`	`+ }`
`124`	`128`	`}`
`125`	`129`
`126`	`130`	`var headerBuilder = new HeaderBuilder();`
Original file line number	Diff line number	Diff line change
`@@ -22,10 +22,10 @@ public class Request : RequestResponseBase`
`22`	`22`	`/// <summary>`
`23`	`23`	`/// Is Https?`
`24`	`24`	`/// </summary>`
`25`		`- public bool IsHttps => RequestUri.Scheme == ProxyServer.UriSchemeHttps;`
	`25`	`+ public bool IsHttps { get; internal set; }`
`26`	`26`
`27`	`27`	`private ByteString originalUrlData;`
`28`		`- private protected ByteString UrlData;`
	`28`	`+ private ByteString urlData;`
`29`	`29`
`30`	`30`	`internal ByteString OriginalUrlData`
`31`	`31`	`{`
`@@ -37,9 +37,21 @@ internal ByteString OriginalUrlData`
`37`	`37`	`}`
`38`	`38`	`}`
`39`	`39`
`40`		`- internal string Scheme { get; set; } = ProxyServer.UriSchemeHttp;`
	`40`	`+ private protected ByteString UrlData`
	`41`	`+ {`
	`42`	`+ get => urlData;`
	`43`	`+ set`
	`44`	`+ {`
	`45`	`+ urlData = value;`
	`46`	`+ var scheme = getUriScheme(UrlData);`
	`47`	`+ if (scheme.Length > 0)`
	`48`	`+ {`
	`49`	`+ IsHttps = scheme.Equals(ProxyServer.UriSchemeHttps8);`
	`50`	`+ }`
	`51`	`+ }`
	`52`	`+ }`
`41`	`53`
`42`		`- internal string? Hostname { get; set; }`
	`54`	`+ internal string? Authority { get; set; }`
`43`	`55`
`44`	`56`	`/// <summary>`
`45`	`57`	`/// The original request Url.`
`@@ -53,21 +65,21 @@ public Uri RequestUri`
`53`	`65`	`{`
`54`	`66`	`get`
`55`	`67`	`{`
`56`		`- string url;`
`57`		`- if (startsWithUriScheme(UrlData))`
`58`		`- {`
`59`		`- url = UrlData.GetString();`
`60`		`- }`
`61`		`- else`
	`68`	`+ string url = UrlData.GetString();`
	`69`	`+ if (getUriScheme(UrlData).Length == 0)`
`62`	`70`	`{`
`63`		`- string? host = Host ?? Hostname;`
`64`		`- string? hostAndPath = host;`
`65`		`- if (UrlData.Length > 0 && UrlData[0] == '/')`
	`71`	`+ string? hostAndPath = Host ?? Authority;`
	`72`	`+`
	`73`	`+ if (url.StartsWith("/"))`
	`74`	`+ {`
	`75`	`+ hostAndPath += url;`
	`76`	`+ }`
	`77`	`+ else`
`66`	`78`	`{`
`67`		`- hostAndPath += UrlData.GetString();`
	`79`	`+ //throw new Exception($"Invalid URL: '{url}'");`
`68`	`80`	`}`
`69`	`81`
`70`		`- url = string.Concat(Scheme == ProxyServer.UriSchemeHttps ? "https://" : "http://", hostAndPath);`
	`82`	`+ url = string.Concat(IsHttps ? "https://" : "http://", hostAndPath);`
`71`	`83`	`}`
`72`	`84`
`73`	`85`	`try`
`@@ -87,7 +99,16 @@ public Uri RequestUri`
`87`	`99`	`public string Url`
`88`	`100`	`{`
`89`	`101`	`get => UrlData.GetString();`
`90`		`- set => UrlData = value.GetByteString();`
	`102`	`+ set`
	`103`	`+ {`
	`104`	`+ UrlData = value.GetByteString();`
	`105`	`+`
	`106`	`+ if (Host != null)`
	`107`	`+ {`
	`108`	`+ var uri = new Uri(value);`
	`109`	`+ Host = uri.Authority;`
	`110`	`+ }`
	`111`	`+ }`
`91`	`112`	`}`
`92`	`113`
`93`	`114`	`[Obsolete("This property is obsolete. Use Url property instead")]`
`@@ -147,7 +168,7 @@ public bool ExpectContinue`
`147`	`168`	`get`
`148`	`169`	`{`
`149`	`170`	`string? headerValue = Headers.GetHeaderValueOrNull(KnownHeaders.Expect);`
`150`		`- return headerValue != null && headerValue.Equals(KnownHeaders.Expect100Continue);`
	`171`	`+ return KnownHeaders.Expect100Continue.Equals(headerValue);`
`151`	`172`	`}`
`152`	`173`	`}`
`153`	`174`
`@@ -290,11 +311,11 @@ private static bool isAllUpper(string input)`
`290`	`311`	`return true;`
`291`	`312`	`}`
`292`	`313`
`293`		`- private bool startsWithUriScheme(ByteString str)`
	`314`	`+ private ByteString getUriScheme(ByteString str)`
`294`	`315`	`{`
`295`	`316`	`if (str.Length < 3)`
`296`	`317`	`{`
`297`		`- return false;`
	`318`	`+ return ByteString.Empty;`
`298`	`319`	`}`
`299`	`320`
`300`	`321`	`// regex: "^[a-z]*://"`
`@@ -310,26 +331,26 @@ private bool startsWithUriScheme(ByteString str)`
`310`	`331`
`311`	`332`	`if (ch < 'A' \|\| ch > 'z' \|\| (ch > 'Z' && ch < 'a')) // ASCII letter`
`312`	`333`	`{`
`313`		`- return false;`
	`334`	`+ return ByteString.Empty;`
`314`	`335`	`}`
`315`	`336`	`}`
`316`	`337`
`317`	`338`	`if (str[i++] != ':')`
`318`	`339`	`{`
`319`		`- return false;`
	`340`	`+ return ByteString.Empty;`
`320`	`341`	`}`
`321`	`342`
`322`	`343`	`if (str[i++] != '/')`
`323`	`344`	`{`
`324`		`- return false;`
	`345`	`+ return ByteString.Empty;`
`325`	`346`	`}`
`326`	`347`
`327`	`348`	`if (str[i] != '/')`
`328`	`349`	`{`
`329`		`- return false;`
	`350`	`+ return ByteString.Empty;`
`330`	`351`	`}`
`331`	`352`
`332`		`- return true;`
	`353`	`+ return new ByteString(str.Data.Slice(0, i - 2));`
`333`	`354`	`}`
`334`	`355`	`}`
`335`	`356`	`}`
Original file line number	Diff line number	Diff line change
`@@ -263,9 +263,9 @@ private static async Task copyHttp2FrameAsync(Stream input, Stream output,`
`263`	`263`
`264`	`264`	`request.HttpVersion = HttpVersion.Version20;`
`265`	`265`	`request.Method = method.GetString();`
	`266`	`+ request.IsHttps = headerListener.Scheme == ProxyServer.UriSchemeHttps;`
	`267`	`+ request.Authority = headerListener.Authority.GetString();`
`266`	`268`	`request.OriginalUrlData = path;`
`267`		`- request.Scheme = headerListener.Scheme;`
`268`		`- request.Hostname = headerListener.Authority.GetString();`
`269`	`269`
`270`	`270`	`//request.RequestUri = headerListener.GetUri();`
`271`	`271`	`}`
`@@ -468,9 +468,10 @@ private static async Task sendHeader(Http2Settings settings, Http2FrameHeader fr`
`468`	`468`
`469`	`469`	`if (rr is Request request)`
`470`	`470`	`{`
	`471`	`+ var uri = request.RequestUri;`
`471`	`472`	`encoder.EncodeHeader(writer, StaticTable.KnownHeaderMethod, request.Method.GetByteString());`
`472`		`- encoder.EncodeHeader(writer, StaticTable.KnownHeaderAuhtority, request.RequestUri.Host.GetByteString());`
`473`		`- encoder.EncodeHeader(writer, StaticTable.KnownHeaderScheme, request.RequestUri.Scheme.GetByteString());`
	`473`	`+ encoder.EncodeHeader(writer, StaticTable.KnownHeaderAuhtority, uri.Authority.GetByteString());`
	`474`	`+ encoder.EncodeHeader(writer, StaticTable.KnownHeaderScheme, uri.Scheme.GetByteString());`
`474`	`475`	`encoder.EncodeHeader(writer, StaticTable.KnownHeaderPath, request.Url.GetByteString(), false,`
`475`	`476`	`HpackUtil.IndexType.None, false);`
`476`	`477`	`}`
`@@ -572,10 +573,6 @@ class Http2Settings`
`572`	`573`
`573`	`574`	`class MyHeaderListener : IHeaderListener`
`574`	`575`	`{`
`575`		`- private static ByteString SchemeHttp = (ByteString)ProxyServer.UriSchemeHttp;`
`576`		`-`
`577`		`- private static ByteString SchemeHttps = (ByteString)ProxyServer.UriSchemeHttps;`
`578`		`-`
`579`	`576`	`private readonly Action<ByteString, ByteString> addHeaderFunc;`
`580`	`577`
`581`	`578`	`public ByteString Method { get; private set; }`
`@@ -592,12 +589,12 @@ public string Scheme`
`592`	`589`	`{`
`593`	`590`	`get`
`594`	`591`	`{`
`595`		`- if (scheme.Equals(SchemeHttp))`
	`592`	`+ if (scheme.Equals(ProxyServer.UriSchemeHttp8))`
`596`	`593`	`{`
`597`	`594`	`return ProxyServer.UriSchemeHttp;`
`598`	`595`	`}`
`599`	`596`
`600`		`- if (scheme.Equals(SchemeHttps))`
	`597`	`+ if (scheme.Equals(ProxyServer.UriSchemeHttps8))`
`601`	`598`	`{`
`602`	`599`	`return ProxyServer.UriSchemeHttps;`
`603`	`600`	`}`