Add property for client local endoint (not the lsitening endpoint, t…

examples/Titanium.Web.Proxy.Examples.Wpf/MainWindow.xaml

@@ -31,7 +31,7 @@
                     <GridViewColumn Header="Process" DisplayMemberBinding="{Binding Process}" />
                     <GridViewColumn Header="SentBytes" DisplayMemberBinding="{Binding SentDataCount}" />
                     <GridViewColumn Header="ReceivedBytes" DisplayMemberBinding="{Binding ReceivedDataCount}" />
-                    <GridViewColumn Header="ClientEndPoint" DisplayMemberBinding="{Binding ClientEndPoint}" />
+                    <GridViewColumn Header="ClientRemoteEndPoint" DisplayMemberBinding="{Binding ClientRemoteEndPoint}" />
                     <GridViewColumn Header="ClientConnectionId" DisplayMemberBinding="{Binding ClientConnectionId}" />
                     <GridViewColumn Header="ServerConnectionId" DisplayMemberBinding="{Binding ServerConnectionId}" />
                 </GridView>

examples/Titanium.Web.Proxy.Examples.Wpf/MainWindow.xaml.cs

@@ -229,7 +229,8 @@ private SessionListItem createSessionListItem(SessionEventArgsBase e)
                 ClientConnectionId = e.ClientConnectionId,
                 ServerConnectionId = e.ServerConnectionId,
                 HttpClient = e.HttpClient,
-                ClientEndPoint = e.ClientEndPoint,
+                ClientRemoteEndPoint = e.ClientRemoteEndPoint,
+                ClientLocalEndPoint = e.ClientLocalEndPoint,
                 IsTunnelConnect = isTunnelConnect
             };
 

examples/Titanium.Web.Proxy.Examples.Wpf/SessionListItem.cs

@@ -38,7 +38,9 @@ public Guid ServerConnectionId
 
         public HttpWebClient HttpClient { get; set; }
 
-        public IPEndPoint ClientEndPoint { get; set; }
+        public IPEndPoint ClientLocalEndPoint { get; set; }
+
+        public IPEndPoint ClientRemoteEndPoint { get; set; }
 
         public bool IsTunnelConnect { get; set; }
 

src/Titanium.Web.Proxy/EventArguments/SessionEventArgs.cs

@@ -25,7 +25,7 @@ public class SessionEventArgs : SessionEventArgsBase
         /// </summary>
         private bool reRequest;
 
-        private WebSocketDecoder webSocketDecoder;
+        private WebSocketDecoder? webSocketDecoder;
 
         /// <summary>
         ///     Is this session a HTTP/2 promise?
@@ -221,7 +221,7 @@ internal async Task SyphonOutBodyAsync(bool isRequest, CancellationToken cancell
 
             var reader = isRequest ? (HttpStream)ClientStream : HttpClient.Connection.Stream;
 
-            await reader.CopyBodyAsync(requestResponse, true, new NullWriter(), TransformationMode.None, null, cancellationToken);
+            await reader.CopyBodyAsync(requestResponse, true, NullWriter.Instance, TransformationMode.None, null, cancellationToken);
         }
 
         /// <summary>

src/Titanium.Web.Proxy/EventArguments/SessionEventArgsBase.cs

@@ -94,9 +94,14 @@ public bool EnableWinAuth
         public bool IsHttps => HttpClient.Request.IsHttps;
 
         /// <summary>
-        ///     Client End Point.
+        ///     Client Local End Point.
         /// </summary>
-        public IPEndPoint ClientEndPoint => (IPEndPoint)ClientConnection.RemoteEndPoint;
+        public IPEndPoint ClientLocalEndPoint => (IPEndPoint)ClientConnection.LocalEndPoint;
+
+        /// <summary>
+        ///     Client Remote End Point.
+        /// </summary>
+        public IPEndPoint ClientRemoteEndPoint => (IPEndPoint)ClientConnection.RemoteEndPoint;
 
         /// <summary>
         ///    The web client used to communicate with server for this session.

src/Titanium.Web.Proxy/ExplicitClientHandler.cs

@@ -37,7 +37,6 @@ private async Task handleClient(ExplicitProxyEndPoint endPoint, TcpClientConnect
 
             Task<TcpServerConnection>? prefetchConnectionTask = null;
             bool closeServerConnection = false;
-            bool calledRequestHandler = false;
 
             try
             {
@@ -375,10 +374,11 @@ await Http2Helper.SendHttp2(clientStream, connection.Stream,
                     }
                 }
 
-                calledRequestHandler = true;
+                var prefetchTask = prefetchConnectionTask;
+                prefetchConnectionTask = null;
 
                 // Now create the request
-                await handleHttpSessionRequest(endPoint, clientStream, cancellationTokenSource, connectArgs, prefetchConnectionTask);
+                await handleHttpSessionRequest(endPoint, clientStream, cancellationTokenSource, connectArgs, prefetchTask);
             }
             catch (ProxyException e)
             {
@@ -407,10 +407,7 @@ await Http2Helper.SendHttp2(clientStream, connection.Stream,
                     cancellationTokenSource.Cancel();
                 }
 
-                if (!calledRequestHandler)
-                {
-                    await tcpConnectionFactory.Release(prefetchConnectionTask, closeServerConnection);
-                }
+                await tcpConnectionFactory.Release(prefetchConnectionTask, closeServerConnection);
 
                 clientStream.Dispose();
             }

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

@@ -8,6 +8,10 @@ internal class NullWriter : IHttpStreamWriter
     {
         public static NullWriter Instance { get; } = new NullWriter();
 
+        private NullWriter()
+        {
+        }
+
         public void Write(byte[] buffer, int offset, int count)
         {
         }

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

@@ -580,20 +580,22 @@ internal async Task Release(TcpServerConnection connection, bool close = false)
 
         internal async Task Release(Task<TcpServerConnection>? connectionCreateTask, bool closeServerConnection)
         {
-            if (connectionCreateTask != null)
+            if (connectionCreateTask == null)
             {
-                TcpServerConnection? connection = null;
-                try
-                {
-                    connection = await connectionCreateTask;
-                }
-                catch { }
-                finally
+                return;
+            }
+
+            TcpServerConnection? connection = null;
+            try
+            {
+                connection = await connectionCreateTask;
+            }
+            catch { }
+            finally
+            {
+                if (connection != null)
                 {
-                    if (connection != null)
-                    {
-                        await Release(connection, closeServerConnection);
-                    }
+                    await Release(connection, closeServerConnection);
                 }
             }
         }