AcceptAsync with existing Socket not implemented on Unix

[stephentoub]

Windows has built-in support for accepting into an existing socket, something not available on Unix. But we can approximate it in the .NET layer on Unix, e.g. by accepting into a new socket and transferring over the SafeCloseHandle and related state. This will allow the same APIs to be used cross-platform so that code running on Windows gets the intended benefits while not having to fork based on the OS.

[marcusturewicz]

So is the idea to implement the equivalent of:

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

Lines 110 to 130 in b5f5d71

	internal unsafe bool AcceptEx(SafeSocketHandle listenSocketHandle,
	SafeSocketHandle acceptSocketHandle,
	IntPtr buffer,
	int len,
	int localAddressLength,
	int remoteAddressLength,
	out int bytesReceived,
	NativeOverlapped* overlapped)
	{
	EnsureDynamicWinsockMethods();
	AcceptExDelegate acceptEx = _dynamicWinsockMethods!.GetDelegate<AcceptExDelegate>(listenSocketHandle);
	return acceptEx(listenSocketHandle,
	acceptSocketHandle,
	buffer,
	len,
	localAddressLength,
	remoteAddressLength,
	out bytesReceived,
	overlapped);
	}

in Socket.Unix.cs ?

[stephentoub]

Today on Unix we just throw a PlatformNotSupportedException if a non-null accept Socket is supplied:

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

Lines 149 to 159 in c09a25e

	private Socket? GetOrCreateAcceptSocket(Socket? acceptSocket, bool unused, string propertyName, out SafeSocketHandle? handle)
	{
	// AcceptSocket is not supported on Unix.
	if (acceptSocket != null)
	{
	throw new PlatformNotSupportedException(SR.PlatformNotSupported_AcceptSocket);
	}
	handle = null;
	return null;
	}

Instead, we would need to:

• Allow a non-null Socket, but put it aside for the moment
• Perform the accept using a new Socket, as the Unix implementation already does today
• Copy the relevant state from the new Socket into the supplied non-null accept Socket, e.g. most of the fields on the Socket instance
• Clear out / suppress finalization the temporary accept socket that was created

Or something along those lines.

[marcusturewicz]

Ok. I'll have a go at implementing this, including tests.

[stephentoub]

Thanks!

[marcusturewicz]

Is this on the right track?

        private Socket? GetOrCreateAcceptSocket(Socket? acceptSocket, bool unused, string propertyName, out SafeSocketHandle? handle)
        {
            if (acceptSocket != null)
            {
                // Accept into new Socket
                using var socket = new Socket(_addressFamily, _socketType, _protocolType);

                // Copy fields to acceptSocket
                acceptSocket._addressFamily = socket._addressFamily;
                acceptSocket._cachedTaskEventArgs = socket._cachedTaskEventArgs;
                acceptSocket._caches = socket._caches;
                acceptSocket._closeTimeout = socket._closeTimeout;
                acceptSocket._disposed = socket._disposed;
                acceptSocket._handle = socket._handle;
                acceptSocket._isConnected = socket._isConnected;
                acceptSocket._isDisconnected = socket._isDisconnected;
                acceptSocket._isListening = socket._isListening;
                acceptSocket._lastReceiveHandle = socket._lastReceiveHandle;
                acceptSocket._lastReceiveThread = socket._lastReceiveThread;
                acceptSocket._lastReceiveTick = socket._lastReceiveTick;
                acceptSocket._nonBlockingConnectInProgress = socket._nonBlockingConnectInProgress;
                acceptSocket._nonBlockingConnectRightEndPoint = socket._nonBlockingConnectRightEndPoint;
                acceptSocket._protocolType = socket._protocolType;
                acceptSocket._receivingPacketInformation = socket._receivingPacketInformation;
                acceptSocket._remoteEndPoint = socket._remoteEndPoint;
                acceptSocket._rightEndPoint = socket._rightEndPoint;
                acceptSocket._socketType = socket._socketType;
                acceptSocket._willBlock = socket._willBlock;
                acceptSocket._willBlockInternal = socket._willBlockInternal;

                handle = acceptSocket._handle;

                return acceptSocket;
            }

            handle = null;
            return null;
        }

[stephentoub]

Yes and no. Yes, that's the kind of copying to be done. No, this isn't the right place to do it: it would need to be after the accept had already happened. You also need to be careful not to tear down the new socket when cleaning up the temporary one.

[liveans]

I'm going to take a look at this issue @karelz

[davidfowl]

We should fix the milestone right?