Merge pull request #683 from justcoding121/master

honfika · web-flow · commit 51e83bae38a5 · 2019-11-26T16:11:12.000+01:00
beta
diff --git a/src/Titanium.Web.Proxy/EventArguments/SessionEventArgs.cs b/src/Titanium.Web.Proxy/EventArguments/SessionEventArgs.cs
@@ -4,12 +4,10 @@
 using System.Net;
 using System.Threading;
 using System.Threading.Tasks;
-using Titanium.Web.Proxy.Compression;
 using Titanium.Web.Proxy.Helpers;
 using Titanium.Web.Proxy.Http;
 using Titanium.Web.Proxy.Http.Responses;
 using Titanium.Web.Proxy.Models;
-using Titanium.Web.Proxy.Network;
 using Titanium.Web.Proxy.Network.Tcp;
 using Titanium.Web.Proxy.StreamExtended.Network;
 
diff --git a/src/Titanium.Web.Proxy/ExplicitClientHandler.cs b/src/Titanium.Web.Proxy/ExplicitClientHandler.cs
@@ -52,18 +52,16 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
                 if (await HttpHelper.IsConnectMethod(clientStream, BufferPool, cancellationToken) == 1)
                 {
                     // read the first line HTTP command
-                    string? httpCmd = await clientStream.ReadLineAsync(cancellationToken);
-                    if (string.IsNullOrEmpty(httpCmd))
+                    var requestLine = await clientStream.ReadRequestLine(cancellationToken);
+                    if (requestLine.IsEmpty())
                     {
                         return;
                     }
 
-                    Request.ParseRequestLine(httpCmd!, out string _, out var httpUrl, out var version);
-
-                    var connectRequest = new ConnectRequest(httpUrl.GetString())
+                    var connectRequest = new ConnectRequest(requestLine.RequestUri.GetString())
                     {
-                        RequestUriString8 = httpUrl,
-                        HttpVersion = version
+                        RequestUriString8 = requestLine.RequestUri,
+                        HttpVersion = requestLine.Version
                     };
 
                     await HeaderParser.ReadHeaders(clientStream, connectRequest.Headers, cancellationToken);
@@ -105,7 +103,7 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
                     }
 
                     // write back successful CONNECT response
-                    var response = ConnectResponse.CreateSuccessfulConnectResponse(version);
+                    var response = ConnectResponse.CreateSuccessfulConnectResponse(requestLine.Version);
 
                     // Set ContentLength explicitly to properly handle HTTP 1.0
                     response.ContentLength = 0;
@@ -175,7 +173,7 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
                             }
                         }
 
-                        string connectHostname = httpUrl.GetString();
+                        string connectHostname = requestLine.RequestUri.GetString();
                         int idx = connectHostname.IndexOf(":");
                         if (idx >= 0)
                         {
@@ -214,6 +212,8 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
 
                             // HTTPS server created - we can now decrypt the client's traffic
                             clientStream = new HttpClientStream(sslStream, BufferPool);
+                            sslStream = null; // clientStream was created, no need to keep SSL stream reference
+
                             clientStream.DataRead += (o, args) => connectArgs.OnDecryptedDataSent(args.Buffer, args.Offset, args.Count);
                             clientStream.DataWrite += (o, args) => connectArgs.OnDecryptedDataReceived(args.Buffer, args.Offset, args.Count);
                         }
diff --git a/src/Titanium.Web.Proxy/Helpers/HttpClientStream.cs b/src/Titanium.Web.Proxy/Helpers/HttpClientStream.cs
@@ -29,5 +29,19 @@ internal async ValueTask WriteResponseAsync(Response response, CancellationToken
             
             await WriteAsync(response, headerBuilder, cancellationToken);
         }
+
+        internal async ValueTask<RequestStatusInfo> ReadRequestLine(CancellationToken cancellationToken = default)
+        {
+            // read the first line HTTP command
+            string? httpCmd = await ReadLineAsync(cancellationToken);
+            if (string.IsNullOrEmpty(httpCmd))
+            {
+                return default;
+            }
+
+            Request.ParseRequestLine(httpCmd!, out string method, out var requestUri, out var version);
+
+            return new RequestStatusInfo { Method = method, RequestUri = requestUri, Version = version };
+        }
     }
 }
diff --git a/src/Titanium.Web.Proxy/Helpers/RequestStatusInfo.cs b/src/Titanium.Web.Proxy/Helpers/RequestStatusInfo.cs
@@ -0,0 +1,19 @@
+﻿using System;
+using Titanium.Web.Proxy.Models;
+
+namespace Titanium.Web.Proxy.Helpers
+{
+    struct RequestStatusInfo
+    {
+        public string Method { get; set; }
+
+        public ByteString RequestUri { get; set; }
+
+        public Version Version { get; set; }
+
+        public bool IsEmpty()
+        {
+            return Method == null && RequestUri.Length == 0 && Version == null;
+        }
+    }
+}
diff --git a/src/Titanium.Web.Proxy/Helpers/TcpHelper.cs b/src/Titanium.Web.Proxy/Helpers/TcpHelper.cs
@@ -100,12 +100,10 @@ private static uint toNetworkByteOrder(uint port)
         /// <param name="onDataSend"></param>
         /// <param name="onDataReceive"></param>
         /// <param name="cancellationTokenSource"></param>
-        /// <param name="exceptionFunc"></param>
         /// <returns></returns>
         private static async Task sendRawTap(Stream clientStream, Stream serverStream, IBufferPool bufferPool,
             Action<byte[], int, int>? onDataSend, Action<byte[], int, int>? onDataReceive,
-            CancellationTokenSource cancellationTokenSource,
-            ExceptionHandler exceptionFunc)
+            CancellationTokenSource cancellationTokenSource)
         {
             // Now async relay all server=>client & client=>server data
             var sendRelay =
@@ -139,8 +137,7 @@ internal static Task SendRaw(Stream clientStream, Stream serverStream, IBufferPo
         {
             // todo: fix APM mode
             return sendRawTap(clientStream, serverStream, bufferPool, onDataSend, onDataReceive,
-                cancellationTokenSource,
-                exceptionFunc);
+                cancellationTokenSource);
         }
     }
 }
diff --git a/src/Titanium.Web.Proxy/Http/Request.cs b/src/Titanium.Web.Proxy/Http/Request.cs
@@ -254,7 +254,7 @@ internal override void EnsureBodyAvailable(bool throwWhenNotReadYet = true)
             }
         }
 
-        internal static void ParseRequestLine(string httpCmd, out string httpMethod, out ByteString httpUrl,
+        internal static void ParseRequestLine(string httpCmd, out string method, out ByteString requestUri,
             out Version version)
         {
             int firstSpace = httpCmd.IndexOf(' ');
@@ -269,21 +269,21 @@ internal static void ParseRequestLine(string httpCmd, out string httpMethod, out
             // break up the line into three components (method, remote URL & Http Version)
 
             // Find the request Verb
-            httpMethod = httpCmd.Substring(0, firstSpace);
-            if (!isAllUpper(httpMethod))
+            method = httpCmd.Substring(0, firstSpace);
+            if (!isAllUpper(method))
             {
-                httpMethod = httpMethod.ToUpper();
+                method = method.ToUpper();
             }
 
             version = HttpHeader.Version11;
 
             if (firstSpace == lastSpace)
             {
-                httpUrl = (ByteString)httpCmd.AsSpan(firstSpace + 1).ToString();
+                requestUri = (ByteString)httpCmd.AsSpan(firstSpace + 1).ToString();
             }
             else
             {
-                httpUrl = (ByteString)httpCmd.AsSpan(firstSpace + 1, lastSpace - firstSpace - 1).ToString();
+                requestUri = (ByteString)httpCmd.AsSpan(firstSpace + 1, lastSpace - firstSpace - 1).ToString();
 
                 // parse the HTTP version
                 var httpVersion = httpCmd.AsSpan(lastSpace + 1);
diff --git a/src/Titanium.Web.Proxy/Http/RequestResponseBase.cs b/src/Titanium.Web.Proxy/Http/RequestResponseBase.cs
@@ -196,7 +196,7 @@ internal set
         ///     Use the encoding specified to decode the byte[] data to string
         /// </summary>
         [Browsable(false)]
-        public string BodyString => bodyString ?? (bodyString = Encoding.GetString(Body));
+        public string BodyString => bodyString ??= Encoding.GetString(Body);
 
         /// <summary>
         ///     Was the body read by user?
diff --git a/src/Titanium.Web.Proxy/Network/Certificate/BCCertificateMaker.cs b/src/Titanium.Web.Proxy/Network/Certificate/BCCertificateMaker.cs
@@ -1,7 +1,6 @@
 ﻿using System;
 using System.IO;
 using System.Security.Cryptography.X509Certificates;
-using System.Threading;
 using Org.BouncyCastle.Asn1;
 using Org.BouncyCastle.Asn1.Pkcs;
 using Org.BouncyCastle.Asn1.X509;
@@ -219,11 +218,9 @@ private X509Certificate2 makeCertificateInternal(string hostName, string subject
         /// <param name="subject">The s subject cn.</param>
         /// <param name="switchToMtaIfNeeded">if set to <c>true</c> [switch to MTA if needed].</param>
         /// <param name="signingCert">The signing cert.</param>
-        /// <param name="cancellationToken">Task cancellation token</param>
         /// <returns>X509Certificate2.</returns>
         private X509Certificate2 makeCertificateInternal(string subject,
-            bool switchToMtaIfNeeded, X509Certificate2? signingCert = null,
-            CancellationToken cancellationToken = default)
+            bool switchToMtaIfNeeded, X509Certificate2? signingCert = null)
         {
             return makeCertificateInternal(subject, $"CN={subject}",
                 DateTime.UtcNow.AddDays(-certificateGraceDays), DateTime.UtcNow.AddDays(certificateValidDays),
diff --git a/src/Titanium.Web.Proxy/RequestHandler.cs b/src/Titanium.Web.Proxy/RequestHandler.cs
@@ -58,8 +58,8 @@ private async Task handleHttpSessionRequest(ProxyEndPoint endPoint, TcpClientCon
                     }
 
                     // read the request line
-                    string? httpCmd = await clientStream.ReadLineAsync(cancellationToken);
-                    if (string.IsNullOrEmpty(httpCmd))
+                    var requestLine = await clientStream.ReadRequestLine(cancellationToken);
+                    if (requestLine.IsEmpty())
                     {
                         return;
                     }
@@ -73,8 +73,6 @@ private async Task handleHttpSessionRequest(ProxyEndPoint endPoint, TcpClientCon
                     {
                         try
                         {
-                            Request.ParseRequestLine(httpCmd!, out string httpMethod, out ByteString httpUrl, out var version);
-
                             // Read the request headers in to unique and non-unique header collections
                             await HeaderParser.ReadHeaders(clientStream, args.HttpClient.Request.Headers,
                                 cancellationToken);
@@ -86,10 +84,10 @@ await HeaderParser.ReadHeaders(clientStream, args.HttpClient.Request.Headers,
                                 request.Authority = connectRequest.Authority;
                             }
 
-                            request.RequestUriString8 = httpUrl;
+                            request.RequestUriString8 = requestLine.RequestUri;
 
-                            request.Method = httpMethod;
-                            request.HttpVersion = version;
+                            request.Method = requestLine.Method;
+                            request.HttpVersion = requestLine.Version;
 
                             if (!args.IsTransparent)
                             {
@@ -293,13 +291,13 @@ private async Task<RetryResult> handleHttpSessionRequest(SessionEventArgs args,
                 }
 
                 // construct the web request that we are going to issue on behalf of the client.
-                await handleHttpSessionRequest(connection, args);
+                await handleHttpSessionRequest(args);
                 return true;
 
             }, generator, serverConnection);
         }
 
-        private async Task handleHttpSessionRequest(TcpServerConnection connection, SessionEventArgs args)
+        private async Task handleHttpSessionRequest(SessionEventArgs args)
         {
             var cancellationToken = args.CancellationTokenSource.Token;
             var request = args.HttpClient.Request;
diff --git a/src/Titanium.Web.Proxy/StreamExtended/SslTools.cs b/src/Titanium.Web.Proxy/StreamExtended/SslTools.cs
@@ -154,7 +154,7 @@ internal class SslTools
 
                 if(extensionsStartPosition < recordLength + 5)
                 {
-                    extensions = await ReadExtensions(majorVersion, minorVersion, peekStream, bufferPool, cancellationToken);
+                    extensions = await ReadExtensions(majorVersion, minorVersion, peekStream, cancellationToken);
                 }
 
                 var clientHelloInfo = new ClientHelloInfo(3, majorVersion, minorVersion, random, sessionId, ciphers, peekStream.Position)
@@ -292,7 +292,7 @@ public static async Task<bool> IsServerHello(IPeekStream stream, IBufferPool buf
 
                 if (extensionsStartPosition < recordLength + 5)
                 {
-                   extensions = await ReadExtensions(majorVersion, minorVersion, peekStream, bufferPool, cancellationToken);
+                   extensions = await ReadExtensions(majorVersion, minorVersion, peekStream, cancellationToken);
                 }
 
                 var serverHelloInfo = new ServerHelloInfo(3, majorVersion, minorVersion, random, sessionId, cipherSuite, peekStream.Position)
@@ -308,7 +308,7 @@ public static async Task<bool> IsServerHello(IPeekStream stream, IBufferPool buf
             return null;
         }
 
-        private static async Task<Dictionary<string, SslExtension>?> ReadExtensions(int majorVersion, int minorVersion, PeekStreamReader peekStreamReader, IBufferPool bufferPool, CancellationToken cancellationToken)
+        private static async Task<Dictionary<string, SslExtension>?> ReadExtensions(int majorVersion, int minorVersion, PeekStreamReader peekStreamReader, CancellationToken cancellationToken)
         {
             Dictionary<string, SslExtension>? extensions = null;
             if (majorVersion > 3 || majorVersion == 3 && minorVersion >= 1)
diff --git a/src/Titanium.Web.Proxy/TransparentClientHandler.cs b/src/Titanium.Web.Proxy/TransparentClientHandler.cs
@@ -75,14 +75,15 @@ private async Task handleClient(TransparentProxyEndPoint endPoint, TcpClientConn
 
                             // HTTPS server created - we can now decrypt the client's traffic
                             clientStream = new HttpClientStream(sslStream, BufferPool);
+                            sslStream = null; // clientStream was created, no need to keep SSL stream reference
                         }
                         catch (Exception e)
                         {
-                            var certname = certificate?.GetNameInfo(X509NameType.SimpleName, false);
+                            var certName = certificate?.GetNameInfo(X509NameType.SimpleName, false);
                             var session = new SessionEventArgs(this, endPoint, clientConnection, clientStream, null,
                                 cancellationTokenSource);
                             throw new ProxyConnectException(
-                                $"Couldn't authenticate host '{httpsHostName}' with certificate '{certname}'.", e, session);
+                                $"Couldn't authenticate host '{httpsHostName}' with certificate '{certName}'.", e, session);
                         }
                       
                     }

Original file line number	Diff line number	Diff line change
`@@ -52,18 +52,16 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect`
`52`	`52`	`if (await HttpHelper.IsConnectMethod(clientStream, BufferPool, cancellationToken) == 1)`
`53`	`53`	`{`
`54`	`54`	`// read the first line HTTP command`
`55`		`- string? httpCmd = await clientStream.ReadLineAsync(cancellationToken);`
`56`		`- if (string.IsNullOrEmpty(httpCmd))`
	`55`	`+ var requestLine = await clientStream.ReadRequestLine(cancellationToken);`
	`56`	`+ if (requestLine.IsEmpty())`
`57`	`57`	`{`
`58`	`58`	`return;`
`59`	`59`	`}`
`60`	`60`
`61`		`- Request.ParseRequestLine(httpCmd!, out string _, out var httpUrl, out var version);`
`62`		`-`
`63`		`- var connectRequest = new ConnectRequest(httpUrl.GetString())`
	`61`	`+ var connectRequest = new ConnectRequest(requestLine.RequestUri.GetString())`
`64`	`62`	`{`
`65`		`- RequestUriString8 = httpUrl,`
`66`		`- HttpVersion = version`
	`63`	`+ RequestUriString8 = requestLine.RequestUri,`
	`64`	`+ HttpVersion = requestLine.Version`
`67`	`65`	`};`
`68`	`66`
`69`	`67`	`await HeaderParser.ReadHeaders(clientStream, connectRequest.Headers, cancellationToken);`
`@@ -105,7 +103,7 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect`
`105`	`103`	`}`
`106`	`104`
`107`	`105`	`// write back successful CONNECT response`
`108`		`- var response = ConnectResponse.CreateSuccessfulConnectResponse(version);`
	`106`	`+ var response = ConnectResponse.CreateSuccessfulConnectResponse(requestLine.Version);`
`109`	`107`
`110`	`108`	`// Set ContentLength explicitly to properly handle HTTP 1.0`
`111`	`109`	`response.ContentLength = 0;`
`@@ -175,7 +173,7 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect`
`175`	`173`	`}`
`176`	`174`	`}`
`177`	`175`
`178`		`- string connectHostname = httpUrl.GetString();`
	`176`	`+ string connectHostname = requestLine.RequestUri.GetString();`
`179`	`177`	`int idx = connectHostname.IndexOf(":");`
`180`	`178`	`if (idx >= 0)`
`181`	`179`	`{`
`@@ -214,6 +212,8 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect`
`214`	`212`
`215`	`213`	`// HTTPS server created - we can now decrypt the client's traffic`
`216`	`214`	`clientStream = new HttpClientStream(sslStream, BufferPool);`
	`215`	`+ sslStream = null; // clientStream was created, no need to keep SSL stream reference`
	`216`	`+`
`217`	`217`	`clientStream.DataRead += (o, args) => connectArgs.OnDecryptedDataSent(args.Buffer, args.Offset, args.Count);`
`218`	`218`	`clientStream.DataWrite += (o, args) => connectArgs.OnDecryptedDataReceived(args.Buffer, args.Offset, args.Count);`
`219`	`219`	`}`
Original file line number	Diff line number	Diff line change
`@@ -29,5 +29,19 @@ internal async ValueTask WriteResponseAsync(Response response, CancellationToken`
`29`	`29`
`30`	`30`	`await WriteAsync(response, headerBuilder, cancellationToken);`
`31`	`31`	`}`
	`32`	`+`
	`33`	`+ internal async ValueTask<RequestStatusInfo> ReadRequestLine(CancellationToken cancellationToken = default)`
	`34`	`+ {`
	`35`	`+ // read the first line HTTP command`
	`36`	`+ string? httpCmd = await ReadLineAsync(cancellationToken);`
	`37`	`+ if (string.IsNullOrEmpty(httpCmd))`
	`38`	`+ {`
	`39`	`+ return default;`
	`40`	`+ }`
	`41`	`+`
	`42`	`+ Request.ParseRequestLine(httpCmd!, out string method, out var requestUri, out var version);`
	`43`	`+`
	`44`	`+ return new RequestStatusInfo { Method = method, RequestUri = requestUri, Version = version };`
	`45`	`+ }`
`32`	`46`	`}`
`33`	`47`	`}`
Original file line number	Diff line number	Diff line change
`@@ -100,12 +100,10 @@ private static uint toNetworkByteOrder(uint port)`
`100`	`100`	`/// <param name="onDataSend"></param>`
`101`	`101`	`/// <param name="onDataReceive"></param>`
`102`	`102`	`/// <param name="cancellationTokenSource"></param>`
`103`		`- /// <param name="exceptionFunc"></param>`
`104`	`103`	`/// <returns></returns>`
`105`	`104`	`private static async Task sendRawTap(Stream clientStream, Stream serverStream, IBufferPool bufferPool,`
`106`	`105`	`Action<byte[], int, int>? onDataSend, Action<byte[], int, int>? onDataReceive,`
`107`		`- CancellationTokenSource cancellationTokenSource,`
`108`		`- ExceptionHandler exceptionFunc)`
	`106`	`+ CancellationTokenSource cancellationTokenSource)`
`109`	`107`	`{`
`110`	`108`	`// Now async relay all server=>client & client=>server data`
`111`	`109`	`var sendRelay =`
`@@ -139,8 +137,7 @@ internal static Task SendRaw(Stream clientStream, Stream serverStream, IBufferPo`
`139`	`137`	`{`
`140`	`138`	`// todo: fix APM mode`
`141`	`139`	`return sendRawTap(clientStream, serverStream, bufferPool, onDataSend, onDataReceive,`
`142`		`- cancellationTokenSource,`
`143`		`- exceptionFunc);`
	`140`	`+ cancellationTokenSource);`
`144`	`141`	`}`
`145`	`142`	`}`
`146`	`143`	`}`
Original file line number	Diff line number	Diff line change
`@@ -254,7 +254,7 @@ internal override void EnsureBodyAvailable(bool throwWhenNotReadYet = true)`
`254`	`254`	`}`
`255`	`255`	`}`
`256`	`256`
`257`		`- internal static void ParseRequestLine(string httpCmd, out string httpMethod, out ByteString httpUrl,`
	`257`	`+ internal static void ParseRequestLine(string httpCmd, out string method, out ByteString requestUri,`
`258`	`258`	`out Version version)`
`259`	`259`	`{`
`260`	`260`	`int firstSpace = httpCmd.IndexOf(' ');`
`@@ -269,21 +269,21 @@ internal static void ParseRequestLine(string httpCmd, out string httpMethod, out`
`269`	`269`	`// break up the line into three components (method, remote URL & Http Version)`
`270`	`270`
`271`	`271`	`// Find the request Verb`
`272`		`- httpMethod = httpCmd.Substring(0, firstSpace);`
`273`		`- if (!isAllUpper(httpMethod))`
	`272`	`+ method = httpCmd.Substring(0, firstSpace);`
	`273`	`+ if (!isAllUpper(method))`
`274`	`274`	`{`
`275`		`- httpMethod = httpMethod.ToUpper();`
	`275`	`+ method = method.ToUpper();`
`276`	`276`	`}`
`277`	`277`
`278`	`278`	`version = HttpHeader.Version11;`
`279`	`279`
`280`	`280`	`if (firstSpace == lastSpace)`
`281`	`281`	`{`
`282`		`- httpUrl = (ByteString)httpCmd.AsSpan(firstSpace + 1).ToString();`
	`282`	`+ requestUri = (ByteString)httpCmd.AsSpan(firstSpace + 1).ToString();`
`283`	`283`	`}`
`284`	`284`	`else`
`285`	`285`	`{`
`286`		`- httpUrl = (ByteString)httpCmd.AsSpan(firstSpace + 1, lastSpace - firstSpace - 1).ToString();`
	`286`	`+ requestUri = (ByteString)httpCmd.AsSpan(firstSpace + 1, lastSpace - firstSpace - 1).ToString();`
`287`	`287`
`288`	`288`	`// parse the HTTP version`
`289`	`289`	`var httpVersion = httpCmd.AsSpan(lastSpace + 1);`
Original file line number	Diff line number	Diff line change
`@@ -58,8 +58,8 @@ private async Task handleHttpSessionRequest(ProxyEndPoint endPoint, TcpClientCon`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`// read the request line`
`61`		`- string? httpCmd = await clientStream.ReadLineAsync(cancellationToken);`
`62`		`- if (string.IsNullOrEmpty(httpCmd))`
	`61`	`+ var requestLine = await clientStream.ReadRequestLine(cancellationToken);`
	`62`	`+ if (requestLine.IsEmpty())`
`63`	`63`	`{`
`64`	`64`	`return;`
`65`	`65`	`}`
`@@ -73,8 +73,6 @@ private async Task handleHttpSessionRequest(ProxyEndPoint endPoint, TcpClientCon`
`73`	`73`	`{`
`74`	`74`	`try`
`75`	`75`	`{`
`76`		`- Request.ParseRequestLine(httpCmd!, out string httpMethod, out ByteString httpUrl, out var version);`
`77`		`-`
`78`	`76`	`// Read the request headers in to unique and non-unique header collections`
`79`	`77`	`await HeaderParser.ReadHeaders(clientStream, args.HttpClient.Request.Headers,`
`80`	`78`	`cancellationToken);`
`@@ -86,10 +84,10 @@ await HeaderParser.ReadHeaders(clientStream, args.HttpClient.Request.Headers,`
`86`	`84`	`request.Authority = connectRequest.Authority;`
`87`	`85`	`}`
`88`	`86`
`89`		`- request.RequestUriString8 = httpUrl;`
	`87`	`+ request.RequestUriString8 = requestLine.RequestUri;`
`90`	`88`
`91`		`- request.Method = httpMethod;`
`92`		`- request.HttpVersion = version;`
	`89`	`+ request.Method = requestLine.Method;`
	`90`	`+ request.HttpVersion = requestLine.Version;`
`93`	`91`
`94`	`92`	`if (!args.IsTransparent)`
`95`	`93`	`{`
`@@ -293,13 +291,13 @@ private async Task<RetryResult> handleHttpSessionRequest(SessionEventArgs args,`
`293`	`291`	`}`
`294`	`292`
`295`	`293`	`// construct the web request that we are going to issue on behalf of the client.`
`296`		`- await handleHttpSessionRequest(connection, args);`
	`294`	`+ await handleHttpSessionRequest(args);`
`297`	`295`	`return true;`
`298`	`296`
`299`	`297`	`}, generator, serverConnection);`
`300`	`298`	`}`
`301`	`299`
`302`		`- private async Task handleHttpSessionRequest(TcpServerConnection connection, SessionEventArgs args)`
	`300`	`+ private async Task handleHttpSessionRequest(SessionEventArgs args)`
`303`	`301`	`{`
`304`	`302`	`var cancellationToken = args.CancellationTokenSource.Token;`
`305`	`303`	`var request = args.HttpClient.Request;`
Original file line number	Diff line number	Diff line change
`@@ -154,7 +154,7 @@ internal class SslTools`
`154`	`154`
`155`	`155`	`if(extensionsStartPosition < recordLength + 5)`
`156`	`156`	`{`
`157`		`- extensions = await ReadExtensions(majorVersion, minorVersion, peekStream, bufferPool, cancellationToken);`
	`157`	`+ extensions = await ReadExtensions(majorVersion, minorVersion, peekStream, cancellationToken);`
`158`	`158`	`}`
`159`	`159`
`160`	`160`	`var clientHelloInfo = new ClientHelloInfo(3, majorVersion, minorVersion, random, sessionId, ciphers, peekStream.Position)`
`@@ -292,7 +292,7 @@ public static async Task<bool> IsServerHello(IPeekStream stream, IBufferPool buf`
`292`	`292`
`293`	`293`	`if (extensionsStartPosition < recordLength + 5)`
`294`	`294`	`{`
`295`		`- extensions = await ReadExtensions(majorVersion, minorVersion, peekStream, bufferPool, cancellationToken);`
	`295`	`+ extensions = await ReadExtensions(majorVersion, minorVersion, peekStream, cancellationToken);`
`296`	`296`	`}`
`297`	`297`
`298`	`298`	`var serverHelloInfo = new ServerHelloInfo(3, majorVersion, minorVersion, random, sessionId, cipherSuite, peekStream.Position)`
`@@ -308,7 +308,7 @@ public static async Task<bool> IsServerHello(IPeekStream stream, IBufferPool buf`
`308`	`308`	`return null;`
`309`	`309`	`}`
`310`	`310`
`311`		`- private static async Task<Dictionary<string, SslExtension>?> ReadExtensions(int majorVersion, int minorVersion, PeekStreamReader peekStreamReader, IBufferPool bufferPool, CancellationToken cancellationToken)`
	`311`	`+ private static async Task<Dictionary<string, SslExtension>?> ReadExtensions(int majorVersion, int minorVersion, PeekStreamReader peekStreamReader, CancellationToken cancellationToken)`
`312`	`312`	`{`
`313`	`313`	`Dictionary<string, SslExtension>? extensions = null;`
`314`	`314`	`if (majorVersion > 3 \|\| majorVersion == 3 && minorVersion >= 1)`
Original file line number	Diff line number	Diff line change
`@@ -75,14 +75,15 @@ private async Task handleClient(TransparentProxyEndPoint endPoint, TcpClientConn`
`75`	`75`
`76`	`76`	`// HTTPS server created - we can now decrypt the client's traffic`
`77`	`77`	`clientStream = new HttpClientStream(sslStream, BufferPool);`
	`78`	`+ sslStream = null; // clientStream was created, no need to keep SSL stream reference`
`78`	`79`	`}`
`79`	`80`	`catch (Exception e)`
`80`	`81`	`{`
`81`		`- var certname = certificate?.GetNameInfo(X509NameType.SimpleName, false);`
	`82`	`+ var certName = certificate?.GetNameInfo(X509NameType.SimpleName, false);`
`82`	`83`	`var session = new SessionEventArgs(this, endPoint, clientConnection, clientStream, null,`
`83`	`84`	`cancellationTokenSource);`
`84`	`85`	`throw new ProxyConnectException(`
`85`		`- $"Couldn't authenticate host '{httpsHostName}' with certificate '{certname}'.", e, session);`
	`86`	`+ $"Couldn't authenticate host '{httpsHostName}' with certificate '{certName}'.", e, session);`
`86`	`87`	`}`
`87`	`88`
`88`	`89`	`}`