Disable Nagle algorithm on a websocket

[sebas77]

Hi,

as far as I understood, to disable the Nagle algorithm on a websocket, I need to reach the field NoDelay and set it to true. To my surprised, this field is actually unreachable from the interface and I had to use reflection to set it. I am now wondering why I have to hack this option. Any thought?

            Type wstype = _ws.GetType();
            FieldInfo clientSocketField = wstype.GetField("m_Socket", BindingFlags.NonPublic | BindingFlags.Instance);
            object websocket = clientSocketField.GetValue(_ws);

            Type type = websocket.GetType();
            FieldInfo innerWebSocketField = type.GetField("_innerWebSocket", BindingFlags.NonPublic | BindingFlags.Instance);
            object innerWebSocket = innerWebSocketField.GetValue(websocket);

            type = innerWebSocket.GetType();
            FieldInfo webSocketField = type.GetField("_webSocket", BindingFlags.NonPublic | BindingFlags.Instance);
            object webSocket = webSocketField.GetValue(innerWebSocket);

            type = webSocket.GetType();
            FieldInfo streamField = type.GetField("_stream", BindingFlags.NonPublic | BindingFlags.Instance);
            object stream = streamField.GetValue(webSocket);

            if (stream is SslStream sstream)
            {
                type = sstream.GetType();
                PropertyInfo sstreamField = type.GetProperty("InnerStream", BindingFlags.NonPublic | BindingFlags.Instance);
                stream = sstreamField.GetValue(sstream);
            }
            
            type = stream.GetType();
            PropertyInfo socketField = type.GetProperty("Socket", BindingFlags.NonPublic | BindingFlags.Instance);
            Socket socket = socketField.GetValue(stream) as Socket;
            socket.SetSocketOption(SocketOptionLevel.Tcp, SocketOptionName.NoDelay, true);

[HaloFour]

This would be a request for the runtime repository that manages the base class libraries (BCL) and APIs for .NET.

[sebas77]

so you think it is a feature request

[HaloFour]

Possibly. The C# language can only work with the APIs provided by those teams. If they aren't exposing an API to make this change directly you'd have to request one to be added, or maybe they offer a different way to accomplish the same thing.

[sebas77]

sorry I am confused now. Isn't the question already in the dotnet/runtime repo?

[HaloFour]

It is now, looks like someone moved it there, although I don't see that in the history ....

[sebas77]

thanks I suspected so, things move very fast here.

[sebas77]

So far I found out:

The Unity Mono version is using an archived version of CoreFX
This version set NoDelay to false by default (debugged)

the version of the code I am using is supposed to be this, but when I debug I see different code:

https://github.com/Unity-Technologies/mono/blob/2021.3.16f1/mcs/class/referencesource/System/net/System/Net/WebSockets/ClientWebSocket.cs

I cannot find any c# code that uses the NoDelay meaningfully (meaning it affects the behaviour of the code) I wonder if it's used in low level native code.

ServicePointManager.UseNagleAlgorithm = false; doesn't affect the value of the ClientWebSocket

the stream is created with this code:

It doesn't seem I have any other choice than setting the boolean through reflection. However I am not even sure the NoDelay boolean is even used. At least I'd like to have confirmation of that and knowing if I can set it after the creation :/

[stephentoub]

Nagle is disabled by default for HttpClient / WebSockets on .NET Core. I can't speak to the implementation Unity currently uses, but there's also nothing we can do here about the implementation Unity currently uses. Unity's roadmap on getting to use the core libraries from here is described at https://blog.unity.com/technology/unity-and-net-whats-next.

With regards to APIs in .NET Core, if you actually want to enable it, how you do that depends on where you're getting your WebSocket from. WebSocket.CreateFromStream let's you create a WebSocket that wraps an already opened Stream, so wherever you're getting that Stream from is where you'd need to configure Nagle; from WebSocket's perspective, it's agnostic to the underlying connection... it could be created on top of something that's not even a socket-based connection. If you're talking about a ClientWebSocket, .NET 7 includes a ConnectAsync overload that takes an HttpMessageInvoker, so you can pass in an HttpClient configured however you like, and SocketsHttpHandler let's you configure how a connection is established, so you could create a SocketsHttpHandler with a ConnectCallback that enables nagle, construct your HttpClient from that, and pass that HttpClient to ClientWebSocket's ConnectAsync.

[stephentoub]

you are right, but there is a high chance that you would give me enough clues to work it out with Unity mono too. At the moment I wouldn't be able to work it out in .Net core either. Specifically I still don't understand how to set the NoDelay or UseNagleAlgorithm on a ClientWebSocket created from an Uri.

To reiterate, NoDelay is set to true by default, aka don't use nagle.

If your goal is to set NoDelay to false in order to use nagle, something like:

static async Task<WebSocket> ConnectClientWebSocketWithManuallyConfiguredConnection(Uri uri, CancellationToken cancellationToken)
{
    using var hc = new HttpClient(new SocketsHttpHandler()
    {
        ConnectCallback = async (ctx, ct) =>
        {
            var s = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = false };
            try
            {
                await s.ConnectAsync(ctx.DnsEndPoint, ct);
                return new NetworkStream(s, ownsSocket: true);
            }
            catch
            {
                s.Dispose();
                throw;
            }
        }
    });

    var ws = new ClientWebSocket();
    await ws.ConnectAsync(uri, hc, cancellationToken);
    return ws;
}

[sebas77]

nice thank you, I assume this interface is not part of the .net standard 2.1

[stephentoub]

I assume this interface is not part of the .net standard 2.1

Correct.

[sebas77]

yep, that's a good point, while .net core and mono unity have different implementations, at least I know I am using a net standard 2.1 compliant interface (which as you suspected doesn't have those features)

[sillykelvin]

@sebas77 Sorry to disturb, may I ask how did you solve this problem in the last? We have met the same problem, the runtime implementation used by our Unity sets NoDelay to false by default, and it does not have class SocketsHttpHandler mentioned above.