prefetch fix

honfika · honfika · commit c75ad1a5aa68 · 2020-09-24T18:07:49.000+02:00
diff --git a/examples/Titanium.Web.Proxy.Examples.WindowsService/App.config b/examples/Titanium.Web.Proxy.Examples.WindowsService/App.config
@@ -45,7 +45,7 @@
         <value>True</value>
       </setting>
       <setting name="EnableTcpServerConnectionPrefetch" serializeAs="String">
-        <value>False</value>
+        <value>True</value>
       </setting>
       <setting name="EnableWinAuth" serializeAs="String">
         <value>False</value>
diff --git a/examples/Titanium.Web.Proxy.Examples.WindowsService/Properties/Settings.Designer.cs b/examples/Titanium.Web.Proxy.Examples.WindowsService/Properties/Settings.Designer.cs
diff --git a/examples/Titanium.Web.Proxy.Examples.WindowsService/Properties/Settings.settings b/examples/Titanium.Web.Proxy.Examples.WindowsService/Properties/Settings.settings
@@ -21,7 +21,7 @@
       <Value Profile="(Default)">True</Value>
     </Setting>
     <Setting Name="EnableTcpServerConnectionPrefetch" Type="System.Boolean" Scope="Application">
-      <Value Profile="(Default)">False</Value>
+      <Value Profile="(Default)">True</Value>
     </Setting>
     <Setting Name="EnableWinAuth" Type="System.Boolean" Scope="Application">
       <Value Profile="(Default)">False</Value>
diff --git a/src/Titanium.Web.Proxy/ExplicitClientHandler.cs b/src/Titanium.Web.Proxy/ExplicitClientHandler.cs
@@ -35,7 +35,7 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
 
             var clientStream = new HttpClientStream(clientConnection, clientConnection.GetStream(), BufferPool, cancellationToken);
 
-            Task<TcpServerConnection>? prefetchConnectionTask = null;
+            Task<TcpServerConnection?>? prefetchConnectionTask = null;
             bool closeServerConnection = false;
 
             try
@@ -145,13 +145,16 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
                                     // todo: this is a hack, because Titanium does not support HTTP protocol changing currently
                                     var connection = await tcpConnectionFactory.GetServerConnection(this, connectArgs,
                                         true, SslExtensions.Http2ProtocolAsList,
-                                        true, cancellationToken);
+                                        true, true, cancellationToken);
 
-                                    http2Supported = connection.NegotiatedApplicationProtocol ==
-                                                     SslApplicationProtocol.Http2;
+                                    if (connection != null)
+                                    {
+                                        http2Supported = connection.NegotiatedApplicationProtocol ==
+                                                         SslApplicationProtocol.Http2;
 
-                                    // release connection back to pool instead of closing when connection pool is enabled.
-                                    await tcpConnectionFactory.Release(connection, true);
+                                        // release connection back to pool instead of closing when connection pool is enabled.
+                                        await tcpConnectionFactory.Release(connection, true);
+                                    }
                                 }
                                 catch (Exception)
                                 {
@@ -162,22 +165,11 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
 
                         if (EnableTcpServerConnectionPrefetch)
                         {
-                            IPAddress[]? ipAddresses = null;
-                            try
-                            {
-                                // make sure the host can be resolved before creating the prefetch task
-                                ipAddresses = await Dns.GetHostAddressesAsync(connectArgs.HttpClient.Request.RequestUri.Host);
-                            }
-                            catch (SocketException) { }
-
-                            if (ipAddresses != null && ipAddresses.Length > 0)
-                            {
-                                // don't pass cancellation token here
-                                // it could cause floating server connections when client exits
-                                prefetchConnectionTask = tcpConnectionFactory.GetServerConnection(this, connectArgs,
-                                                        true, null, false,
-                                                        CancellationToken.None);
-                            }
+                            // don't pass cancellation token here
+                            // it could cause floating server connections when client exits
+                            prefetchConnectionTask = tcpConnectionFactory.GetServerConnection(this, connectArgs,
+                                                    true, null, false, true,
+                                                    CancellationToken.None);
                         }
 
                         string connectHostname = requestLine.RequestUri.GetString();
@@ -272,9 +264,9 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
                         // create new connection to server.
                         // If we detected that client tunnel CONNECTs without SSL by checking for empty client hello then 
                         // this connection should not be HTTPS.
-                        var connection = await tcpConnectionFactory.GetServerConnection(this, connectArgs,
+                        var connection = (await tcpConnectionFactory.GetServerConnection(this, connectArgs,
                                                         true, null,
-                                                        true, cancellationToken);
+                                                        true, false, cancellationToken))!;
 
                         try
                         {
@@ -349,9 +341,9 @@ await TcpHelper.SendRaw(clientStream, connection.Stream, BufferPool,
                             throw new Exception($"HTTP/2 Protocol violation. Empty string expected, '{line}' received");
                         }
 
-                        var connection = await tcpConnectionFactory.GetServerConnection(this, connectArgs,
+                        var connection = (await tcpConnectionFactory.GetServerConnection(this, connectArgs,
                                                         true, SslExtensions.Http2ProtocolAsList,
-                                                        true, cancellationToken);
+                                                        true, false, cancellationToken))!;
                         try
                         {
 #if NETSTANDARD2_1
diff --git a/src/Titanium.Web.Proxy/Network/Tcp/TcpConnectionFactory.cs b/src/Titanium.Web.Proxy/Network/Tcp/TcpConnectionFactory.cs
@@ -154,7 +154,7 @@ internal Task<TcpServerConnection> GetServerConnection(ProxyServer proxyServer,
                 applicationProtocols = new List<SslApplicationProtocol> { applicationProtocol };
             }
 
-            return GetServerConnection(proxyServer, session, isConnect, applicationProtocols, noCache, cancellationToken);
+            return GetServerConnection(proxyServer, session, isConnect, applicationProtocols, noCache, false, cancellationToken)!;
         }
 
         /// <summary>
@@ -165,10 +165,11 @@ internal Task<TcpServerConnection> GetServerConnection(ProxyServer proxyServer,
         /// <param name="isConnect">Is this a CONNECT request.</param>
         /// <param name="applicationProtocols"></param>
         /// <param name="noCache">if set to <c>true</c> [no cache].</param>
+        /// <param name="prefetch">if set to <c>true</c> [prefetch].</param>
         /// <param name="cancellationToken">The cancellation token for this async task.</param>
         /// <returns></returns>
-        internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxyServer, SessionEventArgsBase session, bool isConnect,
-            List<SslApplicationProtocol>? applicationProtocols, bool noCache, CancellationToken cancellationToken)
+        internal async Task<TcpServerConnection?> GetServerConnection(ProxyServer proxyServer, SessionEventArgsBase session, bool isConnect,
+            List<SslApplicationProtocol>? applicationProtocols, bool noCache, bool prefetch, CancellationToken cancellationToken)
         {
             var customUpStreamProxy = session.CustomUpStreamProxy;
 
@@ -208,7 +209,7 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxySe
             var upStreamEndPoint = session.HttpClient.UpStreamEndPoint ?? proxyServer.UpStreamEndPoint;
             var upStreamProxy = customUpStreamProxy ?? (isHttps ? proxyServer.UpStreamHttpsProxy : proxyServer.UpStreamHttpProxy);
             return await GetServerConnection(proxyServer, host, port, session.HttpClient.Request.HttpVersion, isHttps,
-                applicationProtocols, isConnect, session, upStreamEndPoint, upStreamProxy, noCache, cancellationToken);
+                applicationProtocols, isConnect, session, upStreamEndPoint, upStreamProxy, noCache, prefetch, cancellationToken);
         }
 
         /// <summary>
@@ -225,12 +226,13 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxySe
         /// <param name="upStreamEndPoint">The local upstream endpoint to make request via.</param>
         /// <param name="externalProxy">The external proxy to make request via.</param>
         /// <param name="noCache">Not from cache/create new connection.</param>
+        /// <param name="prefetch">if set to <c>true</c> [prefetch].</param>
         /// <param name="cancellationToken">The cancellation token for this async task.</param>
         /// <returns></returns>
-        internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxyServer, string remoteHostName, int remotePort,
+        internal async Task<TcpServerConnection?> GetServerConnection(ProxyServer proxyServer, string remoteHostName, int remotePort,
             Version httpVersion, bool isHttps, List<SslApplicationProtocol>? applicationProtocols, bool isConnect,
             SessionEventArgsBase sessionArgs, IPEndPoint? upStreamEndPoint, IExternalProxy? externalProxy,
-            bool noCache, CancellationToken cancellationToken)
+            bool noCache, bool prefetch, CancellationToken cancellationToken)
         {
             var sslProtocol = sessionArgs.ClientConnection.SslProtocol;
             var cacheKey = GetConnectionCacheKey(remoteHostName, remotePort,
@@ -259,7 +261,7 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxySe
             }
 
             var connection = await createServerConnection(remoteHostName, remotePort, httpVersion, isHttps, sslProtocol,
-                applicationProtocols, isConnect, proxyServer, sessionArgs, upStreamEndPoint, externalProxy, cacheKey, cancellationToken);
+                applicationProtocols, isConnect, proxyServer, sessionArgs, upStreamEndPoint, externalProxy, cacheKey, prefetch, cancellationToken);
 
             return connection;
         }
@@ -279,12 +281,13 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxySe
         /// <param name="upStreamEndPoint">The local upstream endpoint to make request via.</param>
         /// <param name="externalProxy">The external proxy to make request via.</param>
         /// <param name="cacheKey">The connection cache key</param>
+        /// <param name="prefetch">if set to <c>true</c> [prefetch].</param>
         /// <param name="cancellationToken">The cancellation token for this async task.</param>
         /// <returns></returns>
-        private async Task<TcpServerConnection> createServerConnection(string remoteHostName, int remotePort,
+        private async Task<TcpServerConnection?> createServerConnection(string remoteHostName, int remotePort,
             Version httpVersion, bool isHttps, SslProtocols sslProtocol, List<SslApplicationProtocol>? applicationProtocols, bool isConnect,
             ProxyServer proxyServer, SessionEventArgsBase sessionArgs, IPEndPoint? upStreamEndPoint, IExternalProxy? externalProxy, string cacheKey,
-            CancellationToken cancellationToken)
+            bool prefetch, CancellationToken cancellationToken)
         {
             // deny connection to proxy end points to avoid infinite connection loop.
             if (Server.ProxyEndPoints.Any(x => x.Port == remotePort) 
@@ -350,6 +353,11 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost
                 var ipAddresses = await Dns.GetHostAddressesAsync(hostname);
                 if (ipAddresses == null || ipAddresses.Length == 0)
                 {
+                    if (prefetch)
+                    {
+                        return null;
+                    }
+
                     throw new Exception($"Could not resolve the hostname {hostname}");
                 }
 
@@ -486,10 +494,15 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost
                         {
                             sessionArgs.CustomUpStreamProxyUsed = newUpstreamProxy;
                             sessionArgs.TimeLine["Retrying Upstream Proxy Connection"] = DateTime.UtcNow;
-                            return await createServerConnection(remoteHostName, remotePort, httpVersion, isHttps, sslProtocol, applicationProtocols, isConnect, proxyServer, sessionArgs, upStreamEndPoint, externalProxy, cacheKey, cancellationToken);
+                            return await createServerConnection(remoteHostName, remotePort, httpVersion, isHttps, sslProtocol, applicationProtocols, isConnect, proxyServer, sessionArgs, upStreamEndPoint, externalProxy, cacheKey, prefetch, cancellationToken);
                         }
                     }
 
+                    if (prefetch)
+                    {
+                        return null;
+                    }
+
                     throw new Exception($"Could not establish connection to {hostname}", lastException);
                 }
 
@@ -502,7 +515,7 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost
 
                 stream = new HttpServerStream(new NetworkStream(tcpServerSocket, true), proxyServer.BufferPool, cancellationToken);
 
-                if ((externalProxy != null && externalProxy.ProxyType == ExternalProxyType.Http) && (isConnect || isHttps))
+                if (externalProxy != null && externalProxy.ProxyType == ExternalProxyType.Http && (isConnect || isHttps))
                 {
                     var authority = $"{remoteHostName}:{remotePort}".GetByteString();
                     var connectRequest = new ConnectRequest(authority)
@@ -658,7 +671,7 @@ internal async Task Release(TcpServerConnection connection, bool close = false)
             }
         }
 
-        internal async Task Release(Task<TcpServerConnection>? connectionCreateTask, bool closeServerConnection)
+        internal async Task Release(Task<TcpServerConnection?>? connectionCreateTask, bool closeServerConnection)
         {
             if (connectionCreateTask == null)
             {
diff --git a/src/Titanium.Web.Proxy/ProxyServer.cs b/src/Titanium.Web.Proxy/ProxyServer.cs
@@ -182,9 +182,9 @@ public ProxyServer(string? rootCertificateName, string? rootCertificateIssuerNam
         ///     corresponding server connection process using CONNECT hostname or SNI hostname on a separate task so that after parsing client request
         ///     we will have the server connection immediately ready or in the process of getting ready.
         ///     If a server connection is available in cache then this prefetch task will immediately return with the available connection from cache.
-        ///     Defaults to false.
+        ///     Defaults to true.
         /// </summary>
-        public bool EnableTcpServerConnectionPrefetch { get; set; } = false;
+        public bool EnableTcpServerConnectionPrefetch { get; set; } = true;
 
         /// <summary>
         /// Gets or sets a Boolean value that specifies whether server and client stream Sockets are using the Nagle algorithm.
diff --git a/src/Titanium.Web.Proxy/RequestHandler.cs b/src/Titanium.Web.Proxy/RequestHandler.cs
@@ -35,7 +35,7 @@ public partial class ProxyServer
         /// <param name="isHttps">Is HTTPS</param>
         private async Task handleHttpSessionRequest(ProxyEndPoint endPoint, HttpClientStream clientStream,
             CancellationTokenSource cancellationTokenSource, TunnelConnectSessionEventArgs? connectArgs = null,
-            Task<TcpServerConnection>? prefetchConnectionTask = null, bool isHttps = false)
+            Task<TcpServerConnection?>? prefetchConnectionTask = null, bool isHttps = false)
         {
             var connectRequest = connectArgs?.HttpClient.ConnectRequest;
 
diff --git a/src/Titanium.Web.Proxy/TransparentClientHandler.cs b/src/Titanium.Web.Proxy/TransparentClientHandler.cs
@@ -91,10 +91,10 @@ private async Task handleClient(TransparentBaseProxyEndPoint endPoint, TcpClient
                     else
                     {
                         var sessionArgs = new SessionEventArgs(this, endPoint, clientStream, null, cancellationTokenSource);
-                        var connection = await tcpConnectionFactory.GetServerConnection(this, httpsHostName, port,
+                        var connection = (await tcpConnectionFactory.GetServerConnection(this, httpsHostName, port,
                                     HttpHeader.VersionUnknown, false, null,
                                     true, sessionArgs, UpStreamEndPoint,
-                                    UpStreamHttpsProxy, true, cancellationToken);
+                                    UpStreamHttpsProxy, true, false, cancellationToken))!;
 
                         try
                         {
diff --git a/tests/Titanium.Web.Proxy.IntegrationTests/Setup/TestProxyServer.cs b/tests/Titanium.Web.Proxy.IntegrationTests/Setup/TestProxyServer.cs
@@ -7,13 +7,16 @@ namespace Titanium.Web.Proxy.IntegrationTests.Setup
 {
     public class TestProxyServer : IDisposable
     {
-        public ProxyServer ProxyServer { get; private set; }
+        public ProxyServer ProxyServer { get; }
+
         public int ListeningPort => ProxyServer.ProxyEndPoints[0].Port;
+        
         public CertificateManager CertificateManager => ProxyServer.CertificateManager;
 
         public TestProxyServer(bool isReverseProxy, ProxyServer upStreamProxy = null)
         {
             ProxyServer = new ProxyServer();
+
             var explicitEndPoint = isReverseProxy ?
                 (ProxyEndPoint)new TransparentProxyEndPoint(IPAddress.Any, 0, true) :
                 new ExplicitProxyEndPoint(IPAddress.Any, 0, true);

Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ internal Task<TcpServerConnection> GetServerConnection(ProxyServer proxyServer,`
`154`	`154`	`applicationProtocols = new List<SslApplicationProtocol> { applicationProtocol };`
`155`	`155`	`}`
`156`	`156`
`157`		`- return GetServerConnection(proxyServer, session, isConnect, applicationProtocols, noCache, cancellationToken);`
	`157`	`+ return GetServerConnection(proxyServer, session, isConnect, applicationProtocols, noCache, false, cancellationToken)!;`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`/// <summary>`
`@@ -165,10 +165,11 @@ internal Task<TcpServerConnection> GetServerConnection(ProxyServer proxyServer,`
`165`	`165`	`/// <param name="isConnect">Is this a CONNECT request.</param>`
`166`	`166`	`/// <param name="applicationProtocols"></param>`
`167`	`167`	`/// <param name="noCache">if set to <c>true</c> [no cache].</param>`
	`168`	`+ /// <param name="prefetch">if set to <c>true</c> [prefetch].</param>`
`168`	`169`	`/// <param name="cancellationToken">The cancellation token for this async task.</param>`
`169`	`170`	`/// <returns></returns>`
`170`		`- internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxyServer, SessionEventArgsBase session, bool isConnect,`
`171`		`- List<SslApplicationProtocol>? applicationProtocols, bool noCache, CancellationToken cancellationToken)`
	`171`	`+ internal async Task<TcpServerConnection?> GetServerConnection(ProxyServer proxyServer, SessionEventArgsBase session, bool isConnect,`
	`172`	`+ List<SslApplicationProtocol>? applicationProtocols, bool noCache, bool prefetch, CancellationToken cancellationToken)`
`172`	`173`	`{`
`173`	`174`	`var customUpStreamProxy = session.CustomUpStreamProxy;`
`174`	`175`
`@@ -208,7 +209,7 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxySe`
`208`	`209`	`var upStreamEndPoint = session.HttpClient.UpStreamEndPoint ?? proxyServer.UpStreamEndPoint;`
`209`	`210`	`var upStreamProxy = customUpStreamProxy ?? (isHttps ? proxyServer.UpStreamHttpsProxy : proxyServer.UpStreamHttpProxy);`
`210`	`211`	`return await GetServerConnection(proxyServer, host, port, session.HttpClient.Request.HttpVersion, isHttps,`
`211`		`- applicationProtocols, isConnect, session, upStreamEndPoint, upStreamProxy, noCache, cancellationToken);`
	`212`	`+ applicationProtocols, isConnect, session, upStreamEndPoint, upStreamProxy, noCache, prefetch, cancellationToken);`
`212`	`213`	`}`
`213`	`214`
`214`	`215`	`/// <summary>`
`@@ -225,12 +226,13 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxySe`
`225`	`226`	`/// <param name="upStreamEndPoint">The local upstream endpoint to make request via.</param>`
`226`	`227`	`/// <param name="externalProxy">The external proxy to make request via.</param>`
`227`	`228`	`/// <param name="noCache">Not from cache/create new connection.</param>`
	`229`	`+ /// <param name="prefetch">if set to <c>true</c> [prefetch].</param>`
`228`	`230`	`/// <param name="cancellationToken">The cancellation token for this async task.</param>`
`229`	`231`	`/// <returns></returns>`
`230`		`- internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxyServer, string remoteHostName, int remotePort,`
	`232`	`+ internal async Task<TcpServerConnection?> GetServerConnection(ProxyServer proxyServer, string remoteHostName, int remotePort,`
`231`	`233`	`Version httpVersion, bool isHttps, List<SslApplicationProtocol>? applicationProtocols, bool isConnect,`
`232`	`234`	`SessionEventArgsBase sessionArgs, IPEndPoint? upStreamEndPoint, IExternalProxy? externalProxy,`
`233`		`- bool noCache, CancellationToken cancellationToken)`
	`235`	`+ bool noCache, bool prefetch, CancellationToken cancellationToken)`
`234`	`236`	`{`
`235`	`237`	`var sslProtocol = sessionArgs.ClientConnection.SslProtocol;`
`236`	`238`	`var cacheKey = GetConnectionCacheKey(remoteHostName, remotePort,`
`@@ -259,7 +261,7 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxySe`
`259`	`261`	`}`
`260`	`262`
`261`	`263`	`var connection = await createServerConnection(remoteHostName, remotePort, httpVersion, isHttps, sslProtocol,`
`262`		`- applicationProtocols, isConnect, proxyServer, sessionArgs, upStreamEndPoint, externalProxy, cacheKey, cancellationToken);`
	`264`	`+ applicationProtocols, isConnect, proxyServer, sessionArgs, upStreamEndPoint, externalProxy, cacheKey, prefetch, cancellationToken);`
`263`	`265`
`264`	`266`	`return connection;`
`265`	`267`	`}`
`@@ -279,12 +281,13 @@ internal async Task<TcpServerConnection> GetServerConnection(ProxyServer proxySe`
`279`	`281`	`/// <param name="upStreamEndPoint">The local upstream endpoint to make request via.</param>`
`280`	`282`	`/// <param name="externalProxy">The external proxy to make request via.</param>`
`281`	`283`	`/// <param name="cacheKey">The connection cache key</param>`
	`284`	`+ /// <param name="prefetch">if set to <c>true</c> [prefetch].</param>`
`282`	`285`	`/// <param name="cancellationToken">The cancellation token for this async task.</param>`
`283`	`286`	`/// <returns></returns>`
`284`		`- private async Task<TcpServerConnection> createServerConnection(string remoteHostName, int remotePort,`
	`287`	`+ private async Task<TcpServerConnection?> createServerConnection(string remoteHostName, int remotePort,`
`285`	`288`	`Version httpVersion, bool isHttps, SslProtocols sslProtocol, List<SslApplicationProtocol>? applicationProtocols, bool isConnect,`
`286`	`289`	`ProxyServer proxyServer, SessionEventArgsBase sessionArgs, IPEndPoint? upStreamEndPoint, IExternalProxy? externalProxy, string cacheKey,`
`287`		`- CancellationToken cancellationToken)`
	`290`	`+ bool prefetch, CancellationToken cancellationToken)`
`288`	`291`	`{`
`289`	`292`	`// deny connection to proxy end points to avoid infinite connection loop.`
`290`	`293`	`if (Server.ProxyEndPoints.Any(x => x.Port == remotePort)`
`@@ -350,6 +353,11 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost`
`350`	`353`	`var ipAddresses = await Dns.GetHostAddressesAsync(hostname);`
`351`	`354`	`if (ipAddresses == null \|\| ipAddresses.Length == 0)`
`352`	`355`	`{`
	`356`	`+ if (prefetch)`
	`357`	`+ {`
	`358`	`+ return null;`
	`359`	`+ }`
	`360`	`+`
`353`	`361`	`throw new Exception($"Could not resolve the hostname {hostname}");`
`354`	`362`	`}`
`355`	`363`
`@@ -486,10 +494,15 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost`
`486`	`494`	`{`
`487`	`495`	`sessionArgs.CustomUpStreamProxyUsed = newUpstreamProxy;`
`488`	`496`	`sessionArgs.TimeLine["Retrying Upstream Proxy Connection"] = DateTime.UtcNow;`
`489`		`- return await createServerConnection(remoteHostName, remotePort, httpVersion, isHttps, sslProtocol, applicationProtocols, isConnect, proxyServer, sessionArgs, upStreamEndPoint, externalProxy, cacheKey, cancellationToken);`
	`497`	`+ return await createServerConnection(remoteHostName, remotePort, httpVersion, isHttps, sslProtocol, applicationProtocols, isConnect, proxyServer, sessionArgs, upStreamEndPoint, externalProxy, cacheKey, prefetch, cancellationToken);`
`490`	`498`	`}`
`491`	`499`	`}`
`492`	`500`
	`501`	`+ if (prefetch)`
	`502`	`+ {`
	`503`	`+ return null;`
	`504`	`+ }`
	`505`	`+`
`493`	`506`	`throw new Exception($"Could not establish connection to {hostname}", lastException);`
`494`	`507`	`}`
`495`	`508`
`@@ -502,7 +515,7 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost`
`502`	`515`
`503`	`516`	`stream = new HttpServerStream(new NetworkStream(tcpServerSocket, true), proxyServer.BufferPool, cancellationToken);`
`504`	`517`
`505`		`- if ((externalProxy != null && externalProxy.ProxyType == ExternalProxyType.Http) && (isConnect \|\| isHttps))`
	`518`	`+ if (externalProxy != null && externalProxy.ProxyType == ExternalProxyType.Http && (isConnect \|\| isHttps))`
`506`	`519`	`{`
`507`	`520`	`var authority = $"{remoteHostName}:{remotePort}".GetByteString();`
`508`	`521`	`var connectRequest = new ConnectRequest(authority)`
`@@ -658,7 +671,7 @@ internal async Task Release(TcpServerConnection connection, bool close = false)`
`658`	`671`	`}`
`659`	`672`	`}`
`660`	`673`
`661`		`- internal async Task Release(Task<TcpServerConnection>? connectionCreateTask, bool closeServerConnection)`
	`674`	`+ internal async Task Release(Task<TcpServerConnection?>? connectionCreateTask, bool closeServerConnection)`
`662`	`675`	`{`
`663`	`676`	`if (connectionCreateTask == null)`
`664`	`677`	`{`
Original file line number	Diff line number	Diff line change
`@@ -35,7 +35,7 @@ public partial class ProxyServer`
`35`	`35`	`/// <param name="isHttps">Is HTTPS</param>`
`36`	`36`	`private async Task handleHttpSessionRequest(ProxyEndPoint endPoint, HttpClientStream clientStream,`
`37`	`37`	`CancellationTokenSource cancellationTokenSource, TunnelConnectSessionEventArgs? connectArgs = null,`
`38`		`- Task<TcpServerConnection>? prefetchConnectionTask = null, bool isHttps = false)`
	`38`	`+ Task<TcpServerConnection?>? prefetchConnectionTask = null, bool isHttps = false)`
`39`	`39`	`{`
`40`	`40`	`var connectRequest = connectArgs?.HttpClient.ConnectRequest;`
`41`	`41`
Original file line number	Diff line number	Diff line change
`@@ -91,10 +91,10 @@ private async Task handleClient(TransparentBaseProxyEndPoint endPoint, TcpClient`
`91`	`91`	`else`
`92`	`92`	`{`
`93`	`93`	`var sessionArgs = new SessionEventArgs(this, endPoint, clientStream, null, cancellationTokenSource);`
`94`		`- var connection = await tcpConnectionFactory.GetServerConnection(this, httpsHostName, port,`
	`94`	`+ var connection = (await tcpConnectionFactory.GetServerConnection(this, httpsHostName, port,`
`95`	`95`	`HttpHeader.VersionUnknown, false, null,`
`96`	`96`	`true, sessionArgs, UpStreamEndPoint,`
`97`		`- UpStreamHttpsProxy, true, cancellationToken);`
	`97`	`+ UpStreamHttpsProxy, true, false, cancellationToken))!;`
`98`	`98`
`99`	`99`	`try`
`100`	`100`	`{`
Original file line number	Diff line number	Diff line change
`@@ -7,13 +7,16 @@ namespace Titanium.Web.Proxy.IntegrationTests.Setup`
`7`	`7`	`{`
`8`	`8`	`public class TestProxyServer : IDisposable`
`9`	`9`	`{`
`10`		`- public ProxyServer ProxyServer { get; private set; }`
	`10`	`+ public ProxyServer ProxyServer { get; }`
	`11`	`+`
`11`	`12`	`public int ListeningPort => ProxyServer.ProxyEndPoints[0].Port;`
	`13`	`+`
`12`	`14`	`public CertificateManager CertificateManager => ProxyServer.CertificateManager;`
`13`	`15`
`14`	`16`	`public TestProxyServer(bool isReverseProxy, ProxyServer upStreamProxy = null)`
`15`	`17`	`{`
`16`	`18`	`ProxyServer = new ProxyServer();`
	`19`	`+`
`17`	`20`	`var explicitEndPoint = isReverseProxy ?`
`18`	`21`	`(ProxyEndPoint)new TransparentProxyEndPoint(IPAddress.Any, 0, true) :`
`19`	`22`	`new ExplicitProxyEndPoint(IPAddress.Any, 0, true);`