detect non-ssl proxy tunnel

Author: antonfirsov

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnection.cs

@@ -43,7 +43,7 @@ internal sealed partial class HttpConnection : HttpConnectionBase
         private static readonly ulong s_http11Bytes = BitConverter.ToUInt64("HTTP/1.1"u8);
 
         private readonly HttpConnectionPool _pool;
-        private readonly Stream _stream;
+        internal readonly Stream _stream;
         private readonly TransportContext? _transportContext;
 
         private HttpRequestMessage? _currentRequest;

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpConnectionPool.cs

@@ -1565,6 +1565,12 @@ public ValueTask<HttpResponseMessage> SendAsync(HttpRequestMessage request, bool
                 case HttpConnectionKind.ProxyTunnel:
                 case HttpConnectionKind.SslProxyTunnel:
                     stream = await EstablishProxyTunnelAsync(async, cancellationToken).ConfigureAwait(false);
+
+                    if (stream is HttpContentStream contentStream && contentStream._connection?._stream is Stream innerStream)
+                    {
+                        remoteEndPoint = GetRemoteEndPoint(innerStream);
+                    }
+
                     break;
 
                 case HttpConnectionKind.SocksTunnel:

src/libraries/System.Net.Http/src/System/Net/Http/SocketsHttpHandler/HttpContentStream.cs

@@ -5,7 +5,7 @@ namespace System.Net.Http
 {
     internal abstract class HttpContentStream : HttpBaseStream
     {
-        protected HttpConnection? _connection;
+        protected internal HttpConnection? _connection;
 
         public HttpContentStream(HttpConnection connection)
         {

src/libraries/System.Net.Http/tests/FunctionalTests/TelemetryTest.cs

@@ -824,6 +824,52 @@ await GetFactoryForVersion(version).CreateServerAsync((originalServer, originalU
             }, UseVersion.ToString()).Dispose();
         }
 
+        [OuterLoop]
+        [ConditionalTheory(typeof(RemoteExecutor), nameof(RemoteExecutor.IsSupported))]
+        [InlineData(false)]
+        [InlineData(true)]
+        public void EventSource_Proxy_LogsIPAddress(bool useSsl)
+        {
+            if (UseVersion.Major == 3)
+            {
+                return;
+            }
+
+            RemoteExecutor.Invoke(static async (string useVersionString, string useSslString) =>
+            {
+                using var listener = new TestEventListener("System.Net.Http", EventLevel.Verbose, eventCounterInterval: 0.1d);
+                listener.AddActivityTracking();
+                var events = new ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)>();
+
+                await listener.RunWithCallbackAsync(e => events.Enqueue((e, e.ActivityId)), async () =>
+                {
+                    using LoopbackProxyServer proxyServer = LoopbackProxyServer.Create();
+
+                    await LoopbackServer.CreateClientAndServerAsync(async uri =>
+                    {
+                        using (HttpClientHandler handler = CreateHttpClientHandler(useVersionString))
+                        using (HttpClient client = CreateHttpClient(handler, useVersionString))
+                        {
+                            handler.Proxy = new WebProxy(proxyServer.Uri);
+                            await client.GetAsync(uri);
+                        }
+                    }, server => server.HandleRequestAsync(), options: new LoopbackServer.Options() { UseSsl = bool.Parse(useSslString) });
+
+                    await WaitForEventCountersAsync(events);
+                });
+
+                EventWrittenEventArgs[] connectionsEstablishedEvents = events.Select(e => e.Event).Where(e => e.EventName == "ConnectionEstablished").ToArray();
+
+                foreach (EventWrittenEventArgs e in connectionsEstablishedEvents)
+                {
+                    IPAddress ip = IPAddress.Parse((string)e.Payload[6]);
+                    Assert.True(ip.Equals(IPAddress.Loopback.MapToIPv6()) ||
+                        ip.Equals(IPAddress.Loopback) ||
+                        ip.Equals(IPAddress.IPv6Loopback));
+                }
+            }, UseVersion.ToString(), useSsl.ToString()).Dispose();
+        }
+
         protected static async Task WaitForEventCountersAsync(ConcurrentQueue<(EventWrittenEventArgs Event, Guid ActivityId)> events)
         {
             DateTime startTime = DateTime.UtcNow;