Merge pull request #727 from justcoding121/beta

stable

Author: honfika

examples/Titanium.Web.Proxy.Examples.Basic/ProxyTestController.cs

@@ -42,6 +42,11 @@ public ProxyTestController()
                     await writeToConsole(exception.Message, ConsoleColor.Red);
                 }
             };
+
+            proxyServer.TcpTimeWaitSeconds = 10;
+            proxyServer.ConnectionTimeOutSeconds = 15;
+            proxyServer.ReuseSocket = false;
+            proxyServer.EnableConnectionPool = false;
             proxyServer.ForwardToUpstreamGateway = true;
             proxyServer.CertificateManager.SaveFakeCertificates = true;
             //proxyServer.ProxyBasicAuthenticateFunc = async (args, userName, password) =>

src/Titanium.Web.Proxy/Helpers/HttpServerStream.cs

@@ -39,15 +39,15 @@ internal async ValueTask<ResponseStatusInfo> ReadResponseStatus(CancellationToke
                 {
                     // is this really possible?
                     httpStatus = await ReadLineAsync(cancellationToken) ??
-                                 throw new ServerConnectionException("Server connection was closed.");
+                                 throw new ServerConnectionException("Server connection was closed. Response status is empty.");
                 }
 
                 Response.ParseResponseLine(httpStatus, out var version, out int statusCode, out string description);
                 return new ResponseStatusInfo { Version = version, StatusCode = statusCode, Description = description };
             }
             catch (Exception e) when (!(e is ServerConnectionException))
             {
-                throw new ServerConnectionException("Server connection was closed.");
+                throw new ServerConnectionException("Server connection was closed. Exception while reading the response status.", e);
             }
         }
     }

src/Titanium.Web.Proxy/Helpers/HttpStream.cs

@@ -1096,7 +1096,12 @@ private async Task copyBodyChunkedAsync(IHttpStreamWriter writer, Action<byte[],
         {
             while (true)
             {
-                string chunkHead = (await ReadLineAsync(cancellationToken))!;
+                string? chunkHead = await ReadLineAsync(cancellationToken);
+                if (chunkHead == null)
+                {
+                    return;
+                }
+
                 int idx = chunkHead.IndexOf(";");
                 if (idx >= 0)
                 {

src/Titanium.Web.Proxy/Network/Tcp/TcpConnectionFactory.cs

@@ -302,6 +302,11 @@ private async Task<TcpServerConnection> createServerConnection(string remoteHost
                 }
             }
 
+            if (isHttps && sslProtocol == SslProtocols.None)
+            {
+                sslProtocol = proxyServer.SupportedSslProtocols;
+            }
+
             bool useUpstreamProxy1 = false;
 
             // check if external proxy is set for HTTP/HTTPS

src/Titanium.Web.Proxy/RequestHandler.cs

@@ -68,7 +68,10 @@ private async Task handleHttpSessionRequest(ProxyEndPoint endPoint, HttpClientSt
                         UserData = connectArgs?.UserData
                     };
 
-                    args.HttpClient.Request.IsHttps = isHttps;
+                    if (isHttps)
+                    {
+                        args.HttpClient.Request.IsHttps = true;
+                    }
 
                     try
                     {
@@ -156,7 +159,19 @@ await HeaderParser.ReadHeaders(clientStream, args.HttpClient.Request.Headers,
                                 }
 
                                 prefetchTask = null;
+                            }
 
+                            if (connection != null)
+                            {
+                                var socket = connection.TcpSocket;
+                                bool part1 = socket.Poll(1000, SelectMode.SelectRead);
+                                bool part2 = socket.Available == 0;
+                                if (part1 & part2)
+                                {
+                                    //connection is closed
+                                    await tcpConnectionFactory.Release(connection, true);
+                                    connection = null;
+                                }
                             }
 
                             // create a new connection if cache key changes.
@@ -283,7 +298,11 @@ private async Task<RetryResult> handleHttpSessionRequest(SessionEventArgs args,
 
                 if (args.HttpClient.Request.UpgradeToWebSocket)
                 {
-                    args.HttpClient.ConnectRequest!.TunnelType = TunnelType.Websocket;
+                    // connectRequest can be null for SOCKS connection
+                    if (args.HttpClient.ConnectRequest != null)
+                    {
+                        args.HttpClient.ConnectRequest!.TunnelType = TunnelType.Websocket;
+                    }
 
                     // if upgrading to websocket then relay the request without reading the contents
                     await handleWebSocketUpgrade(args, args.ClientStream, connection, cancellationTokenSource, cancellationToken);