Fix Sockets hang caused by concurrent Socket disposal (#29786) (#29846)

stephentoub · danmoseley · commit 7ce9270ac70a · 2018-05-30T12:19:17.000-07:00
* Fix Sockets hang caused by concurrent Socket disposal

On Windows, if Socket.Send/ReceiveAsync is used, and there's a race condition where the Socket is disposed of between the time that the Socket checks for disposal and attempts to get a NativeOverlapped for use with the operation, the getting of the NativeOverlapped can throw an exception and cause us to leave a field in an inconsistent state, which in turn can cause the operation to hang, waiting for that state to be reset.

The fix is to correct the order in which we get the NativeOverlapped vs setting the relevant field.

This is a regression in 2.1.

* Change ArgumentException to ObjectDisposedException from concurrent disposal

If Socket is disposed of concurrently with the first operation on it that allocates a native overlapped, if the disposal happens between the check for disposal and the call to BindHandle, BindHandle may end up throwing an ArgumentException, which is not expected out of SendAsync.  We should instead throw an ObjectDisposedException.

* Add test for concurrent Send/ReceiveAsync and Dispose on Socket
diff --git a/src/Common/src/System/Net/SafeCloseSocket.Windows.cs b/src/Common/src/System/Net/SafeCloseSocket.Windows.cs
@@ -64,7 +64,15 @@ public ThreadPoolBoundHandle GetOrAllocateThreadPoolBoundHandle(bool trySkipComp
                     }
                     catch (Exception exception) when (!ExceptionCheck.IsFatal(exception))
                     {
+                        bool closed = IsClosed;
                         CloseAsIs();
+                        if (closed)
+                        {
+                            // If the handle was closed just before the call to BindHandle,
+                            // we could end up getting an ArgumentException, which we should
+                            // instead propagate as an ObjectDisposedException.
+                            throw new ObjectDisposedException(typeof(Socket).FullName, exception);
+                        }
                         throw;
                     }
 
diff --git a/src/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncEventArgs.Windows.cs b/src/System.Net.Sockets/src/System/Net/Sockets/SocketAsyncEventArgs.Windows.cs
@@ -227,9 +227,9 @@ internal unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket han
             }
             catch
             {
+                _singleBufferHandleState = SingleBufferHandleState.None;
                 FreeNativeOverlapped(overlapped);
                 _singleBufferHandle.Dispose();
-                _singleBufferHandleState = SingleBufferHandleState.None;
                 throw;
             }
         }
@@ -261,9 +261,9 @@ internal unsafe SocketError DoOperationConnect(Socket socket, SafeCloseSocket ha
             }
             catch
             {
+                _singleBufferHandleState = SingleBufferHandleState.None;
                 FreeNativeOverlapped(overlapped);
                 _singleBufferHandle.Dispose();
-                _singleBufferHandleState = SingleBufferHandleState.None;
                 throw;
             }
         }
@@ -296,13 +296,13 @@ internal unsafe SocketError DoOperationReceiveSingleBuffer(SafeCloseSocket handl
         {
             fixed (byte* bufferPtr = &MemoryMarshal.GetReference(_buffer.Span))
             {
-                Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None, $"Expected None, got {_singleBufferHandleState}");
-                _singleBufferHandleState = SingleBufferHandleState.InProcess;
-                var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };
-
                 NativeOverlapped* overlapped = AllocateNativeOverlapped();
                 try
                 {
+                    Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None, $"Expected None, got {_singleBufferHandleState}");
+                    _singleBufferHandleState = SingleBufferHandleState.InProcess;
+                    var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };
+
                     SocketFlags flags = _socketFlags;
                     SocketError socketError = Interop.Winsock.WSARecv(
                         handle.DangerousGetHandle(), // to minimize chances of handle recycling from misuse, this should use DangerousAddRef/Release, but it adds too much overhead
@@ -318,8 +318,8 @@ internal unsafe SocketError DoOperationReceiveSingleBuffer(SafeCloseSocket handl
                 }
                 catch
                 {
-                    FreeNativeOverlapped(overlapped);
                     _singleBufferHandleState = SingleBufferHandleState.None;
+                    FreeNativeOverlapped(overlapped);
                     throw;
                 }
             }
@@ -368,13 +368,13 @@ internal unsafe SocketError DoOperationReceiveFromSingleBuffer(SafeCloseSocket h
         {
             fixed (byte* bufferPtr = &MemoryMarshal.GetReference(_buffer.Span))
             {
-                Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);
-                _singleBufferHandleState = SingleBufferHandleState.InProcess;
-                var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };
-
                 NativeOverlapped* overlapped = AllocateNativeOverlapped();
                 try
                 {
+                    Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);
+                    _singleBufferHandleState = SingleBufferHandleState.InProcess;
+                    var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };
+
                     SocketFlags flags = _socketFlags;
                     SocketError socketError = Interop.Winsock.WSARecvFrom(
                         handle.DangerousGetHandle(), // to minimize chances of handle recycling from misuse, this should use DangerousAddRef/Release, but it adds too much overhead
@@ -392,8 +392,8 @@ internal unsafe SocketError DoOperationReceiveFromSingleBuffer(SafeCloseSocket h
                 }
                 catch
                 {
-                    FreeNativeOverlapped(overlapped);
                     _singleBufferHandleState = SingleBufferHandleState.None;
+                    FreeNativeOverlapped(overlapped);
                     throw;
                 }
             }
@@ -549,9 +549,9 @@ internal unsafe SocketError DoOperationReceiveMessageFrom(Socket socket, SafeClo
             }
             catch
             {
+                _singleBufferHandleState = SingleBufferHandleState.None;
                 FreeNativeOverlapped(overlapped);
                 _singleBufferHandle.Dispose();
-                _singleBufferHandleState = SingleBufferHandleState.None;
                 throw;
             }
         }
@@ -564,13 +564,13 @@ internal unsafe SocketError DoOperationSendSingleBuffer(SafeCloseSocket handle)
         {
             fixed (byte* bufferPtr = &MemoryMarshal.GetReference(_buffer.Span))
             {
-                Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);
-                _singleBufferHandleState = SingleBufferHandleState.InProcess;
-                var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };
-
                 NativeOverlapped* overlapped = AllocateNativeOverlapped();
                 try
                 {
+                    Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);
+                    _singleBufferHandleState = SingleBufferHandleState.InProcess;
+                    var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };
+
                     SocketError socketError = Interop.Winsock.WSASend(
                         handle.DangerousGetHandle(), // to minimize chances of handle recycling from misuse, this should use DangerousAddRef/Release, but it adds too much overhead
                         ref wsaBuffer,
@@ -585,8 +585,8 @@ internal unsafe SocketError DoOperationSendSingleBuffer(SafeCloseSocket handle)
                 }
                 catch
                 {
-                    FreeNativeOverlapped(overlapped);
                     _singleBufferHandleState = SingleBufferHandleState.None;
+                    FreeNativeOverlapped(overlapped);
                     throw;
                 }
             }
@@ -738,13 +738,13 @@ internal unsafe SocketError DoOperationSendToSingleBuffer(SafeCloseSocket handle
         {
             fixed (byte* bufferPtr = &MemoryMarshal.GetReference(_buffer.Span))
             {
-                Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);
-                _singleBufferHandleState = SingleBufferHandleState.InProcess;
-                var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };
-
                 NativeOverlapped* overlapped = AllocateNativeOverlapped();
                 try
                 {
+                    Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);
+                    _singleBufferHandleState = SingleBufferHandleState.InProcess;
+                    var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };
+
                     SocketError socketError = Interop.Winsock.WSASendTo(
                         handle.DangerousGetHandle(), // to minimize chances of handle recycling from misuse, this should use DangerousAddRef/Release, but it adds too much overhead
                         ref wsaBuffer,
@@ -761,8 +761,8 @@ internal unsafe SocketError DoOperationSendToSingleBuffer(SafeCloseSocket handle
                 }
                 catch
                 {
-                    FreeNativeOverlapped(overlapped);
                     _singleBufferHandleState = SingleBufferHandleState.None;
+                    FreeNativeOverlapped(overlapped);
                     throw;
                 }
             }
@@ -916,8 +916,8 @@ private void FreePinHandles()
 
             if (_singleBufferHandleState != SingleBufferHandleState.None)
             {
-                _singleBufferHandle.Dispose();
                 _singleBufferHandleState = SingleBufferHandleState.None;
+                _singleBufferHandle.Dispose();
             }
 
             if (_multipleBufferGCHandles != null)
@@ -1142,8 +1142,8 @@ void CompleteCoreSpin() // separate out to help inline the fast path
 
                 if (_singleBufferHandleState == SingleBufferHandleState.Set)
                 {
-                    _singleBufferHandle.Dispose();
                     _singleBufferHandleState = SingleBufferHandleState.None;
+                    _singleBufferHandle.Dispose();
                 }
             }
         }
diff --git a/src/System.Net.Sockets/tests/FunctionalTests/SendReceive.cs b/src/System.Net.Sockets/tests/FunctionalTests/SendReceive.cs
@@ -837,6 +837,90 @@ public void SocketSendReceiveBufferSize_SetZero_ThrowsSocketException()
                 Assert.Equal(e.SocketErrorCode, SocketError.InvalidArgument);
             }
         }
+
+        [Fact]
+        public async Task SendAsync_ConcurrentDispose_SucceedsOrThrowsAppropriateException()
+        {
+            if (UsesSync) return;
+
+            for (int i = 0; i < 20; i++) // run multiple times to attempt to force various interleavings
+            {
+                (Socket client, Socket server) = CreateConnectedSocketPair();
+                using (client)
+                using (server)
+                using (var b = new Barrier(2))
+                {
+                    Task dispose = Task.Factory.StartNew(() =>
+                    {
+                        b.SignalAndWait();
+                        client.Dispose();
+                    }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+
+                    Task send = Task.Factory.StartNew(() =>
+                    {
+                        b.SignalAndWait();
+                        SendAsync(client, new ArraySegment<byte>(new byte[1])).GetAwaiter().GetResult();
+                    }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+
+                    await dispose;
+                    Exception error = await Record.ExceptionAsync(() => send);
+                    if (error != null)
+                    {
+                        Assert.True(error is ObjectDisposedException || error is SocketException, error.ToString());
+                    }
+                }
+            }
+        }
+
+        [Fact]
+        public async Task ReceiveAsync_ConcurrentDispose_SucceedsOrThrowsAppropriateException()
+        {
+            if (UsesSync) return;
+
+            for (int i = 0; i < 20; i++) // run multiple times to attempt to force various interleavings
+            {
+                (Socket client, Socket server) = CreateConnectedSocketPair();
+                using (client)
+                using (server)
+                using (var b = new Barrier(2))
+                {
+                    Task dispose = Task.Factory.StartNew(() =>
+                    {
+                        b.SignalAndWait();
+                        client.Dispose();
+                    }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+
+                    Task send = Task.Factory.StartNew(() =>
+                    {
+                        SendAsync(server, new ArraySegment<byte>(new byte[1])).GetAwaiter().GetResult();
+                        b.SignalAndWait();
+                        ReceiveAsync(client, new ArraySegment<byte>(new byte[1])).GetAwaiter().GetResult();
+                    }, CancellationToken.None, TaskCreationOptions.LongRunning, TaskScheduler.Default);
+
+                    await dispose;
+                    Exception error = await Record.ExceptionAsync(() => send);
+                    if (error != null)
+                    {
+                        Assert.True(error is ObjectDisposedException || error is SocketException, error.ToString());
+                    }
+                }
+            }
+        }
+
+        protected static (Socket, Socket) CreateConnectedSocketPair()
+        {
+            using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
+            {
+                listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
+                listener.Listen(1);
+
+                Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
+                client.Connect(listener.LocalEndPoint);
+                Socket server = listener.Accept();
+
+                return (client, server);
+            }
+        }
     }
 
     public class SendReceive
@@ -1248,21 +1332,6 @@ select Task.Factory.StartNew(() => pair.Item1.Receive(new byte[1]), Cancellation
                 }
             }).Dispose();
         }
-
-        private static (Socket, Socket) CreateConnectedSocketPair()
-        {
-            using (Socket listener = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp))
-            {
-                listener.Bind(new IPEndPoint(IPAddress.Loopback, 0));
-                listener.Listen(1);
-
-                Socket client = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
-                client.Connect(listener.LocalEndPoint);
-                Socket server = listener.Accept();
-
-                return (client, server);
-            }
-        }
     }
 
     public sealed class SendReceiveSyncForceNonBlocking : SendReceive<SocketHelperSyncForceNonBlocking> { }

Original file line number	Diff line number	Diff line change
`@@ -64,7 +64,15 @@ public ThreadPoolBoundHandle GetOrAllocateThreadPoolBoundHandle(bool trySkipComp`
`64`	`64`	`}`
`65`	`65`	`catch (Exception exception) when (!ExceptionCheck.IsFatal(exception))`
`66`	`66`	`{`
	`67`	`+ bool closed = IsClosed;`
`67`	`68`	`CloseAsIs();`
	`69`	`+ if (closed)`
	`70`	`+ {`
	`71`	`+ // If the handle was closed just before the call to BindHandle,`
	`72`	`+ // we could end up getting an ArgumentException, which we should`
	`73`	`+ // instead propagate as an ObjectDisposedException.`
	`74`	`+ throw new ObjectDisposedException(typeof(Socket).FullName, exception);`
	`75`	`+ }`
`68`	`76`	`throw;`
`69`	`77`	`}`
`70`	`78`
Original file line number	Diff line number	Diff line change
`@@ -227,9 +227,9 @@ internal unsafe SocketError DoOperationAccept(Socket socket, SafeCloseSocket han`
`227`	`227`	`}`
`228`	`228`	`catch`
`229`	`229`	`{`
	`230`	`+ _singleBufferHandleState = SingleBufferHandleState.None;`
`230`	`231`	`FreeNativeOverlapped(overlapped);`
`231`	`232`	`_singleBufferHandle.Dispose();`
`232`		`- _singleBufferHandleState = SingleBufferHandleState.None;`
`233`	`233`	`throw;`
`234`	`234`	`}`
`235`	`235`	`}`
`@@ -261,9 +261,9 @@ internal unsafe SocketError DoOperationConnect(Socket socket, SafeCloseSocket ha`
`261`	`261`	`}`
`262`	`262`	`catch`
`263`	`263`	`{`
	`264`	`+ _singleBufferHandleState = SingleBufferHandleState.None;`
`264`	`265`	`FreeNativeOverlapped(overlapped);`
`265`	`266`	`_singleBufferHandle.Dispose();`
`266`		`- _singleBufferHandleState = SingleBufferHandleState.None;`
`267`	`267`	`throw;`
`268`	`268`	`}`
`269`	`269`	`}`
`@@ -296,13 +296,13 @@ internal unsafe SocketError DoOperationReceiveSingleBuffer(SafeCloseSocket handl`
`296`	`296`	`{`
`297`	`297`	`fixed (byte* bufferPtr = &MemoryMarshal.GetReference(_buffer.Span))`
`298`	`298`	`{`
`299`		`- Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None, $"Expected None, got {_singleBufferHandleState}");`
`300`		`- _singleBufferHandleState = SingleBufferHandleState.InProcess;`
`301`		`- var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };`
`302`		`-`
`303`	`299`	`NativeOverlapped* overlapped = AllocateNativeOverlapped();`
`304`	`300`	`try`
`305`	`301`	`{`
	`302`	`+ Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None, $"Expected None, got {_singleBufferHandleState}");`
	`303`	`+ _singleBufferHandleState = SingleBufferHandleState.InProcess;`
	`304`	`+ var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };`
	`305`	`+`
`306`	`306`	`SocketFlags flags = _socketFlags;`
`307`	`307`	`SocketError socketError = Interop.Winsock.WSARecv(`
`308`	`308`	`handle.DangerousGetHandle(), // to minimize chances of handle recycling from misuse, this should use DangerousAddRef/Release, but it adds too much overhead`
`@@ -318,8 +318,8 @@ internal unsafe SocketError DoOperationReceiveSingleBuffer(SafeCloseSocket handl`
`318`	`318`	`}`
`319`	`319`	`catch`
`320`	`320`	`{`
`321`		`- FreeNativeOverlapped(overlapped);`
`322`	`321`	`_singleBufferHandleState = SingleBufferHandleState.None;`
	`322`	`+ FreeNativeOverlapped(overlapped);`
`323`	`323`	`throw;`
`324`	`324`	`}`
`325`	`325`	`}`
`@@ -368,13 +368,13 @@ internal unsafe SocketError DoOperationReceiveFromSingleBuffer(SafeCloseSocket h`
`368`	`368`	`{`
`369`	`369`	`fixed (byte* bufferPtr = &MemoryMarshal.GetReference(_buffer.Span))`
`370`	`370`	`{`
`371`		`- Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);`
`372`		`- _singleBufferHandleState = SingleBufferHandleState.InProcess;`
`373`		`- var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };`
`374`		`-`
`375`	`371`	`NativeOverlapped* overlapped = AllocateNativeOverlapped();`
`376`	`372`	`try`
`377`	`373`	`{`
	`374`	`+ Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);`
	`375`	`+ _singleBufferHandleState = SingleBufferHandleState.InProcess;`
	`376`	`+ var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };`
	`377`	`+`
`378`	`378`	`SocketFlags flags = _socketFlags;`
`379`	`379`	`SocketError socketError = Interop.Winsock.WSARecvFrom(`
`380`	`380`	`handle.DangerousGetHandle(), // to minimize chances of handle recycling from misuse, this should use DangerousAddRef/Release, but it adds too much overhead`
`@@ -392,8 +392,8 @@ internal unsafe SocketError DoOperationReceiveFromSingleBuffer(SafeCloseSocket h`
`392`	`392`	`}`
`393`	`393`	`catch`
`394`	`394`	`{`
`395`		`- FreeNativeOverlapped(overlapped);`
`396`	`395`	`_singleBufferHandleState = SingleBufferHandleState.None;`
	`396`	`+ FreeNativeOverlapped(overlapped);`
`397`	`397`	`throw;`
`398`	`398`	`}`
`399`	`399`	`}`
`@@ -549,9 +549,9 @@ internal unsafe SocketError DoOperationReceiveMessageFrom(Socket socket, SafeClo`
`549`	`549`	`}`
`550`	`550`	`catch`
`551`	`551`	`{`
	`552`	`+ _singleBufferHandleState = SingleBufferHandleState.None;`
`552`	`553`	`FreeNativeOverlapped(overlapped);`
`553`	`554`	`_singleBufferHandle.Dispose();`
`554`		`- _singleBufferHandleState = SingleBufferHandleState.None;`
`555`	`555`	`throw;`
`556`	`556`	`}`
`557`	`557`	`}`
`@@ -564,13 +564,13 @@ internal unsafe SocketError DoOperationSendSingleBuffer(SafeCloseSocket handle)`
`564`	`564`	`{`
`565`	`565`	`fixed (byte* bufferPtr = &MemoryMarshal.GetReference(_buffer.Span))`
`566`	`566`	`{`
`567`		`- Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);`
`568`		`- _singleBufferHandleState = SingleBufferHandleState.InProcess;`
`569`		`- var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };`
`570`		`-`
`571`	`567`	`NativeOverlapped* overlapped = AllocateNativeOverlapped();`
`572`	`568`	`try`
`573`	`569`	`{`
	`570`	`+ Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);`
	`571`	`+ _singleBufferHandleState = SingleBufferHandleState.InProcess;`
	`572`	`+ var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };`
	`573`	`+`
`574`	`574`	`SocketError socketError = Interop.Winsock.WSASend(`
`575`	`575`	`handle.DangerousGetHandle(), // to minimize chances of handle recycling from misuse, this should use DangerousAddRef/Release, but it adds too much overhead`
`576`	`576`	`ref wsaBuffer,`
`@@ -585,8 +585,8 @@ internal unsafe SocketError DoOperationSendSingleBuffer(SafeCloseSocket handle)`
`585`	`585`	`}`
`586`	`586`	`catch`
`587`	`587`	`{`
`588`		`- FreeNativeOverlapped(overlapped);`
`589`	`588`	`_singleBufferHandleState = SingleBufferHandleState.None;`
	`589`	`+ FreeNativeOverlapped(overlapped);`
`590`	`590`	`throw;`
`591`	`591`	`}`
`592`	`592`	`}`
`@@ -738,13 +738,13 @@ internal unsafe SocketError DoOperationSendToSingleBuffer(SafeCloseSocket handle`
`738`	`738`	`{`
`739`	`739`	`fixed (byte* bufferPtr = &MemoryMarshal.GetReference(_buffer.Span))`
`740`	`740`	`{`
`741`		`- Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);`
`742`		`- _singleBufferHandleState = SingleBufferHandleState.InProcess;`
`743`		`- var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };`
`744`		`-`
`745`	`741`	`NativeOverlapped* overlapped = AllocateNativeOverlapped();`
`746`	`742`	`try`
`747`	`743`	`{`
	`744`	`+ Debug.Assert(_singleBufferHandleState == SingleBufferHandleState.None);`
	`745`	`+ _singleBufferHandleState = SingleBufferHandleState.InProcess;`
	`746`	`+ var wsaBuffer = new WSABuffer { Length = _count, Pointer = (IntPtr)(bufferPtr + _offset) };`
	`747`	`+`
`748`	`748`	`SocketError socketError = Interop.Winsock.WSASendTo(`
`749`	`749`	`handle.DangerousGetHandle(), // to minimize chances of handle recycling from misuse, this should use DangerousAddRef/Release, but it adds too much overhead`
`750`	`750`	`ref wsaBuffer,`
`@@ -761,8 +761,8 @@ internal unsafe SocketError DoOperationSendToSingleBuffer(SafeCloseSocket handle`
`761`	`761`	`}`
`762`	`762`	`catch`
`763`	`763`	`{`
`764`		`- FreeNativeOverlapped(overlapped);`
`765`	`764`	`_singleBufferHandleState = SingleBufferHandleState.None;`
	`765`	`+ FreeNativeOverlapped(overlapped);`
`766`	`766`	`throw;`
`767`	`767`	`}`
`768`	`768`	`}`
`@@ -916,8 +916,8 @@ private void FreePinHandles()`
`916`	`916`
`917`	`917`	`if (_singleBufferHandleState != SingleBufferHandleState.None)`
`918`	`918`	`{`
`919`		`- _singleBufferHandle.Dispose();`
`920`	`919`	`_singleBufferHandleState = SingleBufferHandleState.None;`
	`920`	`+ _singleBufferHandle.Dispose();`
`921`	`921`	`}`
`922`	`922`
`923`	`923`	`if (_multipleBufferGCHandles != null)`
`@@ -1142,8 +1142,8 @@ void CompleteCoreSpin() // separate out to help inline the fast path`
`1142`	`1142`
`1143`	`1143`	`if (_singleBufferHandleState == SingleBufferHandleState.Set)`
`1144`	`1144`	`{`
`1145`		`- _singleBufferHandle.Dispose();`
`1146`	`1145`	`_singleBufferHandleState = SingleBufferHandleState.None;`
	`1146`	`+ _singleBufferHandle.Dispose();`
`1147`	`1147`	`}`
`1148`	`1148`	`}`
`1149`	`1149`	`}`