Add cache for Socket.LocalEndPoint

src/libraries/System.Net.Sockets/src/System/Net/Sockets/Socket.cs

@@ -22,14 +22,22 @@ public partial class Socket : IDisposable
     {
         internal const int DefaultCloseTimeout = -1; // NOTE: changing this default is a breaking change.
 
+        private static readonly HashSet<IPAddress> s_wildcardAddresses = new HashSet<IPAddress>
+        {
+            IPAddress.Any, IPAddress.IPv6Any, IPAddress.Any.MapToIPv6()
+        };
+
         private SafeSocketHandle _handle;
 
         // _rightEndPoint is null if the socket has not been bound.  Otherwise, it is any EndPoint of the
         // correct type (IPEndPoint, etc).
         internal EndPoint? _rightEndPoint;
-        private EndPoint? _localEndPoint; // Cached LocalEndPoint value. Will clear on connect, error and disconnect
         internal EndPoint? _remoteEndPoint;
 
+        // Cached LocalEndPoint value. Cleared on disconnect and error. Cached wildcard addresses are
+        // also cleared on connect and accept.
+        private EndPoint? _localEndPoint;
+
         // These flags monitor if the socket was ever connected at any time and if it still is.
         private bool _isConnected;
         private bool _isDisconnected;
@@ -216,7 +224,7 @@ private unsafe Socket(SafeSocketHandle handle, bool loadPropertiesFromHandle)
                                 }
 
                                 _isConnected = true;
-                                HandleLocalEndPointOnConnect();
+                                UpdateLocalEndPointOnConnect();
                                 break;
 
                             case SocketError.InvalidArgument:
@@ -226,7 +234,7 @@ private unsafe Socket(SafeSocketHandle handle, bool loadPropertiesFromHandle)
                                 // whether we're actually connected or not, err on the side of saying
                                 // we're connected.
                                 _isConnected = true;
-                                HandleLocalEndPointOnConnect();
+                                UpdateLocalEndPointOnConnect();
                                 break;
                         }
                     }
@@ -320,7 +328,7 @@ public int Available
                     // Update the state if we've become connected after a non-blocking connect.
                     _isConnected = true;
                     _rightEndPoint = _nonBlockingConnectRightEndPoint;
-                    HandleLocalEndPointOnConnect();
+                    UpdateLocalEndPointOnConnect();
                     _nonBlockingConnectInProgress = false;
                 }
 
@@ -329,7 +337,7 @@ public int Available
                     return null;
                 }
 
-                //if (_localEndPoint == null)
+                if (_localEndPoint == null)
                 {
                     Internals.SocketAddress socketAddress = IPEndPointExtensions.Serialize(_rightEndPoint);
 
@@ -367,7 +375,7 @@ public int Available
                         // Update the state if we've become connected after a non-blocking connect.
                         _isConnected = true;
                         _rightEndPoint = _nonBlockingConnectRightEndPoint;
-                        HandleLocalEndPointOnConnect();
+                        UpdateLocalEndPointOnConnect();
                         _nonBlockingConnectInProgress = false;
                     }
 
@@ -479,7 +487,7 @@ public bool Connected
                     // Update the state if we've become connected after a non-blocking connect.
                     _isConnected = true;
                     _rightEndPoint = _nonBlockingConnectRightEndPoint;
-                    HandleLocalEndPointOnConnect();
+                    UpdateLocalEndPointOnConnect();
                     _nonBlockingConnectInProgress = false;
                 }
 
@@ -4871,7 +4879,12 @@ internal Socket UpdateAcceptSocket(Socket socket, EndPoint remoteEP)
             socket._protocolType = _protocolType;
             socket._rightEndPoint = _rightEndPoint;
             socket._remoteEndPoint = remoteEP;
-            socket._localEndPoint = _localEndPoint;
+
+            // If the listener socket was bound to a wildcard address, then the `accept` system call
+            // will assign a specific address to the accept socket's local endpoint instead of a
+            // wildcard address. In that case we should not copy listener's wildcard local endpoint.
+
+            socket._localEndPoint = !IsWildcardEndPoint(_localEndPoint) ? _localEndPoint : null;
 
             // The socket is connected.
             socket.SetToConnected();
@@ -4904,44 +4917,35 @@ internal void SetToConnected()
             // some point in time update the perf counter as well.
             _isConnected = true;
             _isDisconnected = false;
-            HandleLocalEndPointOnConnect();
+            UpdateLocalEndPointOnConnect();
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, "now connected");
         }
 
-        private void HandleLocalEndPointOnConnect()
+        private void UpdateLocalEndPointOnConnect()
         {
-            //_localEndPoint = null;
-            if (_localEndPoint == null)
-            {
-                return;
-            }
+            // If the client socket was bound to a wildcard address, then the `connect` system call
+            // will assign a specific address to the client socket's local endpoint instead of a
+            // wildcard address. In that case we should clear the cached wildcard local endpoint.
 
-            if (_localEndPoint is IPEndPoint ipLocalEndpoint)
+            if (IsWildcardEndPoint(_localEndPoint))
             {
-                // If a client socket was bound to a wildcard address, then the `connect` system call
-                // will assign a specific address to the client socket's local endpoint instead of a
-                // wildcard address. In that case we should clear the cached wildcard local endpoint.
-
-                // If a listener socket was bound to a wildcard address, then the `accept` system call
-                // will assign a specific address the accept socket's local endpoint instead of a
-                // wildcard address. In that case we should clear the accept socket's cached wildcard
-                // local endpoint copied from listener.
-
-                if (IsWildcardAddress(ipLocalEndpoint.Address))
-                {
-                    _localEndPoint = null;
-                }
+                _localEndPoint = null;
             }
         }
 
-        private bool IsWildcardAddress(IPAddress address)
+        private bool IsWildcardEndPoint(EndPoint? endPoint)
         {
-            return true;
-            /*return address.ToString() == IPAddress.Any.ToString()
-                    || address.ToString() == IPAddress.IPv6Any.ToString()
-                    || address.ToString() == IPAddress.Any.MapToIPv6().ToString();*/
+            if (endPoint == null)
+            {
+                return false;
+            }
 
-            //return address == IPAddress.Any || address == IPAddress.IPv6Any || address == IPAddress.Any.MapToIPv6();
+            if (endPoint is IPEndPoint ipEndpoint)
+            {
+                return s_wildcardAddresses.Contains(ipEndpoint.Address);
+            }
+
+            return false;
         }
 
         internal void SetToDisconnected()

src/libraries/System.Net.Sockets/tests/FunctionalTests/LocalEndPointTest.cs

@@ -172,6 +172,7 @@ public async Task TcpSocket_ServerBoundToWildcardAddress_AcceptSocketLocalEPIsSp
 
                 Socket accept = await acceptTask;
                 Assert.Equal(accept.RemoteEndPoint, client.LocalEndPoint);
+                Assert.Equal(accept.LocalEndPoint, client.RemoteEndPoint);
 
                 Assert.Equal(Wildcard, GetLocalEPAddress(server)); // server -> stays as wildcard
                 Assert.Equal(Loopback, GetLocalEPAddress(accept)); // accept -> specific
@@ -202,7 +203,7 @@ public async Task TcpSocket_ServerBoundToSpecificAddress_AcceptSocketLocalEPIsSa
             }
         }
 
-        //[Fact]
+        [Fact]
         public void LocalEndPoint_IsCached()
         {
             using (Socket socket = CreateTcpSocket())