Add cache for Socket.LocalEndPoint

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

@@ -27,6 +27,7 @@ public partial class Socket : IDisposable
         // _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;
 
         // These flags monitor if the socket was ever connected at any time and if it still is.
@@ -215,6 +216,7 @@ private unsafe Socket(SafeSocketHandle handle, bool loadPropertiesFromHandle)
                                 }
 
                                 _isConnected = true;
+                                _localEndPoint = null;
                                 break;
 
                             case SocketError.InvalidArgument:
@@ -224,6 +226,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;
+                                _localEndPoint = null;
                                 break;
                         }
                     }
@@ -317,6 +320,7 @@ public int Available
                     // Update the state if we've become connected after a non-blocking connect.
                     _isConnected = true;
                     _rightEndPoint = _nonBlockingConnectRightEndPoint;
+                    _localEndPoint = null;
                     _nonBlockingConnectInProgress = false;
                 }
 
@@ -325,23 +329,27 @@ public int Available
                     return null;
                 }
 
-                Internals.SocketAddress socketAddress = IPEndPointExtensions.Serialize(_rightEndPoint);
-
-                unsafe
+                if (_localEndPoint == null)
                 {
-                    fixed (byte* buffer = socketAddress.Buffer)
-                    fixed (int* bufferSize = &socketAddress.InternalSize)
+                    Internals.SocketAddress socketAddress = IPEndPointExtensions.Serialize(_rightEndPoint);
+
+                    unsafe
                     {
-                        // This may throw ObjectDisposedException.
-                        SocketError errorCode = SocketPal.GetSockName(_handle, buffer, bufferSize);
-                        if (errorCode != SocketError.Success)
+                        fixed (byte* buffer = socketAddress.Buffer)
+                        fixed (int* bufferSize = &socketAddress.InternalSize)
                         {
-                            UpdateStatusAfterSocketErrorAndThrowException(errorCode);
+                            // This may throw ObjectDisposedException.
+                            SocketError errorCode = SocketPal.GetSockName(_handle, buffer, bufferSize);
+                            if (errorCode != SocketError.Success)
+                            {
+                                UpdateStatusAfterSocketErrorAndThrowException(errorCode);
+                            }
                         }
                     }
+                    _localEndPoint = _rightEndPoint.Create(socketAddress);
                 }
 
-                return _rightEndPoint.Create(socketAddress);
+                return _localEndPoint;
             }
         }
 
@@ -359,6 +367,7 @@ public int Available
                         // Update the state if we've become connected after a non-blocking connect.
                         _isConnected = true;
                         _rightEndPoint = _nonBlockingConnectRightEndPoint;
+                        _localEndPoint = null;
                         _nonBlockingConnectInProgress = false;
                     }
 
@@ -470,6 +479,7 @@ public bool Connected
                     // Update the state if we've become connected after a non-blocking connect.
                     _isConnected = true;
                     _rightEndPoint = _nonBlockingConnectRightEndPoint;
+                    _localEndPoint = null;
                     _nonBlockingConnectInProgress = false;
                 }
 
@@ -2303,6 +2313,7 @@ private void DoBeginDisconnect(bool reuseSocket, DisconnectOverlappedAsyncResult
             {
                 SetToDisconnected();
                 _remoteEndPoint = null;
+                _localEndPoint = null;
             }
 
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, $"UnsafeNclNativeMethods.OSSOCK.DisConnectEx returns:{errorCode}");
@@ -2332,6 +2343,7 @@ public void Disconnect(bool reuseSocket)
 
             SetToDisconnected();
             _remoteEndPoint = null;
+            _localEndPoint = null;
         }
 
         // Routine Description:
@@ -2760,6 +2772,7 @@ private void DoBeginSendTo(byte[] buffer, int offset, int size, SocketFlags sock
             catch (ObjectDisposedException)
             {
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
                 throw;
             }
 
@@ -2769,6 +2782,7 @@ private void DoBeginSendTo(byte[] buffer, int offset, int size, SocketFlags sock
                 UpdateSendSocketErrorForDisposed(ref errorCode);
                 // Update the internal state of this socket according to the error before throwing.
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
 
                 throw new SocketException((int)errorCode);
             }
@@ -3148,6 +3162,7 @@ public IAsyncResult BeginReceiveMessageFrom(byte[] buffer, int offset, int size,
             catch (ObjectDisposedException)
             {
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
                 throw;
             }
 
@@ -3157,6 +3172,7 @@ public IAsyncResult BeginReceiveMessageFrom(byte[] buffer, int offset, int size,
             {
                 // Update the internal state of this socket according to the error before throwing.
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
 
                 throw new SocketException((int)errorCode);
             }
@@ -3357,6 +3373,7 @@ private void DoBeginReceiveFrom(byte[] buffer, int offset, int size, SocketFlags
             catch (ObjectDisposedException)
             {
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
                 throw;
             }
 
@@ -3366,6 +3383,7 @@ private void DoBeginReceiveFrom(byte[] buffer, int offset, int size, SocketFlags
             {
                 // Update the internal state of this socket according to the error before throwing.
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
 
                 throw new SocketException((int)errorCode);
             }
@@ -3762,6 +3780,7 @@ private bool ConnectAsync(SocketAsyncEventArgs e, bool userSocket)
                 catch
                 {
                     _rightEndPoint = oldEndPoint;
+                    _localEndPoint = null;
 
                     // Clear in-use flag on event args object.
                     e.Complete();
@@ -4091,6 +4110,7 @@ public bool SendToAsync(SocketAsyncEventArgs e)
             catch
             {
                 _rightEndPoint = null;
+                _localEndPoint = null;
                 // Clear in-use flag on event args object.
                 e.Complete();
                 throw;
@@ -4099,6 +4119,7 @@ public bool SendToAsync(SocketAsyncEventArgs e)
             if (!CheckErrorAndUpdateStatus(socketError))
             {
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
             }
 
             return socketError == SocketError.IOPending;
@@ -4610,6 +4631,7 @@ private IAsyncResult BeginConnectEx(EndPoint remoteEP, bool flowContext, AsyncCa
             {
                 // _rightEndPoint will always equal oldEndPoint.
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
                 throw;
             }
 
@@ -4626,6 +4648,7 @@ private IAsyncResult BeginConnectEx(EndPoint remoteEP, bool flowContext, AsyncCa
                 UpdateConnectSocketErrorForDisposed(ref errorCode);
                 // Update the internal state of this socket according to the error before throwing.
                 _rightEndPoint = oldEndPoint;
+                _localEndPoint = null;
 
                 throw new SocketException((int)errorCode);
             }
@@ -4848,6 +4871,7 @@ internal Socket UpdateAcceptSocket(Socket socket, EndPoint remoteEP)
             socket._protocolType = _protocolType;
             socket._rightEndPoint = _rightEndPoint;
             socket._remoteEndPoint = remoteEP;
+            socket._localEndPoint = _localEndPoint;
 
             // The socket is connected.
             socket.SetToConnected();
@@ -4880,6 +4904,7 @@ internal void SetToConnected()
             // some point in time update the perf counter as well.
             _isConnected = true;
             _isDisconnected = false;
+            _localEndPoint = null;
             if (NetEventSource.Log.IsEnabled()) NetEventSource.Info(this, "now connected");
         }
 

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

@@ -0,0 +1,150 @@
+// Licensed to the .NET Foundation under one or more agreements.
+// The .NET Foundation licenses this file to you under the MIT license.
+
+using System.Threading.Tasks;
+using Xunit;
+
+namespace System.Net.Sockets.Tests
+{
+    public class LocalEndPointTest
+    {
+        [Fact]
+        public void UdpSocket_BoundToWildcardAddress_LocalEPDoesNotChangeOnSendTo()
+        {
+            using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
+            using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
+            {
+                int serverPort = server.BindToAnonymousPort(IPAddress.Any);
+
+                Assert.Null(client.LocalEndPoint);
+
+                int clientPortAfterBind = client.BindToAnonymousPort(IPAddress.Any);
+
+                Assert.Equal(IPAddress.Any, ((IPEndPoint)client.LocalEndPoint).Address);
+
+                var sendToEP = new IPEndPoint(IPAddress.Loopback, serverPort);
+
+                client.SendTo(new byte[] { 1, 2, 3 }, sendToEP);
+
+                Assert.Equal(IPAddress.Any, ((IPEndPoint)client.LocalEndPoint).Address);
+                Assert.Equal(clientPortAfterBind, ((IPEndPoint)client.LocalEndPoint).Port);
+
+                byte[] buf = new byte[3];
+                EndPoint receiveFromEP = new IPEndPoint(IPAddress.Any, 0);
+                server.ReceiveFrom(buf, ref receiveFromEP);
+
+                Assert.Equal(new byte[] { 1, 2, 3 }, buf);
+                Assert.Equal(clientPortAfterBind, ((IPEndPoint)receiveFromEP).Port);
+
+                IAsyncResult sendToResult = client.BeginSendTo(new byte[] { 4, 5, 6 }, 0, 3, SocketFlags.None, sendToEP, null, null);
+                sendToResult.AsyncWaitHandle.WaitOne();
+                client.EndSendTo(sendToResult);
+
+                Assert.Equal(IPAddress.Any, ((IPEndPoint)client.LocalEndPoint).Address);
+                Assert.Equal(clientPortAfterBind, ((IPEndPoint)client.LocalEndPoint).Port);
+
+                buf = new byte[3];
+                receiveFromEP = new IPEndPoint(IPAddress.Any, 0);
+                server.ReceiveFrom(buf, ref receiveFromEP);
+
+                Assert.Equal(new byte[] { 4, 5, 6 }, buf);
+                Assert.Equal(clientPortAfterBind, ((IPEndPoint)receiveFromEP).Port);
+            }
+        }
+
+        [Fact]
+        public void UdpSocket_NotBound_LocalEPBecomesWildcardAddressOnSendTo()
+        {
+            using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
+            using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Dgram, ProtocolType.Udp))
+            {
+                int serverPort = server.BindToAnonymousPort(IPAddress.Any);
+
+                Assert.Null(client.LocalEndPoint);
+
+                var sendToEP = new IPEndPoint(IPAddress.Loopback, serverPort);
+
+                client.SendTo(new byte[] { 1, 2, 3 }, sendToEP);
+
+                Assert.Equal(IPAddress.Any, ((IPEndPoint)client.LocalEndPoint).Address);
+
+                byte[] buf = new byte[3];
+                EndPoint receiveFromEP = new IPEndPoint(IPAddress.Any, 0);
+                server.ReceiveFrom(buf, ref receiveFromEP);
+
+                Assert.Equal(new byte[] { 1, 2, 3 }, buf);
+
+                IAsyncResult sendToResult = client.BeginSendTo(new byte[] { 4, 5, 6 }, 0, 3, SocketFlags.None, sendToEP, null, null);
+                sendToResult.AsyncWaitHandle.WaitOne();
+                client.EndSendTo(sendToResult);
+
+                Assert.Equal(IPAddress.Any, ((IPEndPoint)client.LocalEndPoint).Address);
+
+                buf = new byte[3];
+                receiveFromEP = new IPEndPoint(IPAddress.Any, 0);
+                server.ReceiveFrom(buf, ref receiveFromEP);
+
+                Assert.Equal(new byte[] { 4, 5, 6 }, buf);
+            }
+        }
+
+        [Fact]
+        public async Task TcpSocket_BoundToWildcardAddress_LocalEPChangeToSpecificOnConnnect()
+        {
+            using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+            using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+            {
+                int serverPort = server.BindToAnonymousPort(IPAddress.Any);
+                int clientPortAfterBind = client.BindToAnonymousPort(IPAddress.Any);
+
+                Assert.Equal(IPAddress.Any, ((IPEndPoint)client.LocalEndPoint).Address);
+
+                server.Listen();
+                Task<Socket> acceptTask = server.AcceptAsync();
+
+                client.Connect(new IPEndPoint(IPAddress.Loopback, serverPort));
+
+                Assert.Equal(IPAddress.Loopback, ((IPEndPoint)client.LocalEndPoint).Address);
+                Assert.Equal(clientPortAfterBind, ((IPEndPoint)client.LocalEndPoint).Port);
+
+                Socket accept = await acceptTask;
+                Assert.Equal(accept.RemoteEndPoint, client.LocalEndPoint);
+            }
+        }
+
+        [Fact]
+        public async Task TcpSocket_NotBound_LocalEPChangeToSpecificOnConnnect()
+        {
+            using (Socket server = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+            using (Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+            {
+                int serverPort = server.BindToAnonymousPort(IPAddress.Any);
+                server.Listen();
+                Task<Socket> acceptTask = server.AcceptAsync();
+
+                Assert.Null(client.LocalEndPoint);
+
+                client.Connect(new IPEndPoint(IPAddress.Loopback, serverPort));
+
+                Assert.Equal(IPAddress.Loopback, ((IPEndPoint)client.LocalEndPoint).Address);
+
+                Socket accept = await acceptTask;
+                Assert.Equal(accept.RemoteEndPoint, client.LocalEndPoint);
+            }
+        }
+
+        [Fact]
+        public void LocalEndPoint_IsCached()
+        {
+            using (Socket socket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+            {
+                socket.BindToAnonymousPort(IPAddress.Any);
+
+                EndPoint localEndPointCall1 = socket.LocalEndPoint;
+                EndPoint localEndPointCall2 = socket.LocalEndPoint;
+
+                Assert.Same(localEndPointCall1, localEndPointCall2);
+            }
+        }
+    }
+}

src/libraries/System.Net.Sockets/tests/FunctionalTests/System.Net.Sockets.Tests.csproj

@@ -23,6 +23,7 @@
     <Compile Include="IPPacketInformationTest.cs" />
     <Compile Include="KeepAliveTest.cs" />
     <Compile Include="LingerStateTest.cs" />
+    <Compile Include="LocalEndPointTest.cs" />
     <Compile Include="LoggingTest.cs" />
     <Compile Include="NetworkStreamTest.cs" />
     <Compile Include="ReceiveMessageFrom.cs" />