TCP.Server -> Server.To.Open(host); locks up

[glenneroo]

Issue description:
Since upgrading to v4.0.0, calling Server.To.Open(new Host("0.0.0.0")) locks up on my Meta Quest 3 VR headset and it never returns. On my Android smartphone, it locks up for 20-60 seconds but is accepting connections at least but stops logging/locks up a lot. It seems like a threading issue. V3 runs fine. I made only necessary modifications for my V3 -> V4 code but even if I comment everything out and just do Server.To.Open it gets stuck forever.

The same code runs fine on Windows.

Running generic TCP Listener code works fine e.g.
TcpListener listener = new TcpListener(IPAddress.Any, port);
listener.Start();
Thread listenThread = new Thread(ListenLoop);
listenThread.IsBackground = true;
listenThread.Start();

void ListenLoop() {
while (running) {
var client = listener.AcceptTcpClient();
}
}
etc. I can send my TcpEchoServer test code if needed.

With V3 it doesn't lock up but I am unable to connect any devices while server is running on Android. Client can connect fine in iOS/Android.

Steps to reproduce:
Run server code on any Android device.

Minimal reproduction project:

Netly version:
4.0.0

[alec1o]

Bro, IpAddress.Any needs permition on a lot of OS like:

• Windows (needs administrator access on terminal or program)
• Linux and Macos (needs sudo access on terminal or program)
  I think you should use localhost (127.0.0.1) or custom IP (e.g. 1.1.1.1).

Netly 3 and 4 both use Socket, not TcpListenner.

But you said netly v3 don't have those problems, It mean have impl. problem on v4...
I'll go search about this issue on source-code. Thanks for feedback!

[alec1o]

Netly 3 use Socket.Accept (Sync over thread):
https://github.com/alec1o/Netly/blob/v3.1.0/src/Tcp/TcpServers.cs#L106-L122

Netly 4 ise Socket.BeginAccept (Async):
https://github.com/alec1o/Netly/blob/v4.0.0/src/tcp/partials/TCP.ServerTo.cs#L198-L274

I think by the way, I'll update Netly 4 to use (Sync over thread instead of Async).

• Today (May 6, 2025) I'll fix it and release Netly 4.0.1

[glenneroo]

I rewrote all of my server code to use the example code I posted, without any permissions requests or changes to Android Manifest :) All of my networking works fine suddenly, after 2 days of debugging. So my server uses my own code now, and Client will continue to use Netly 4.0.

[alec1o]

I found the problem, is like what you told. soo I'm confused about the what parallelism way should I use. Thread is best for client connection and server connection, but session connection (Client connection on server-side) is getting me confused.

• Use 1 thread per session? (1K client means 1K threads).
• Use ThreadPool or Task: (Good for less connections, but is never for hight connection volume).
  Why: I'm using block, loop to receive packages, and it should be non blocking thread cool way, how todo? I'm searching about.

If you have ideias about the way to receive connection with less CPU resource, please tell me,

Bro. Honestly I'm sorry for making your job hard, I'll try test to much every scenario's on next tests.

[glenneroo]

1 thread per session should be OK I think? I'm not sure. I honestly think your target audience will not have more than 100 concurrent users - maybe I'm wrong - but I think anyone with "serious" user counts, will implement it themselves, since with that many users they will probably run into other issues which require manual handling of sockets. For your free asset, I would worry about quality over quantity. In any case, you have to be VERY careful about multithreading with Unity, it's easy to cause crashes when using threads with Unity, especially with things like writing log messages, since they must happen on the main thread.

Here is my test code, which creates an ECHO server, so that users can just use 'telnet IP 55000' and they can test connecting quickly with telnet, then typing anything and it will be received by server, printed to screen, and sent back to the client. It's definitely not the most efficient way and it will not handle a lot of users (I guess) - but I only need to handle max 10 users, so I don't care :) You can re-use any of this code if you want, it's nothing special!

using System;
using System.Collections.Concurrent;
using System.Collections.Generic;
using System.IO;
using System.Net;
using System.Net.Sockets;
using System.Text;
using System.Threading;
using UnityEngine;

public class TcpEchoServer : MonoBehaviour {
    private TcpListener listener;
    private Thread listenThread;
    private bool running = false;
    private DateTime lastAcceptTime;
    private CancellationTokenSource cancellationTokenSource;
    private ConcurrentQueue<Action> mainThreadActions = new ConcurrentQueue<Action>();
    private ConcurrentBag<TcpClient> clients = new ConcurrentBag<TcpClient>();

    private const int port = 55000;

    private void Start() {
        StartServer();
        InvokeRepeating(nameof(Heartbeat), 10f, 10f);
    }

    private void Update() {
        // Process any queued actions on the main thread
        while (mainThreadActions.TryDequeue(out Action action)) {
            action?.Invoke();
        }
    }

    // Thread-safe logging that will be executed on the main thread
    private void LogOnMainThread(string message) {
        mainThreadActions.Enqueue(() => Debug.Log(message));
    }

    private void LogErrorOnMainThread(string message) {
        mainThreadActions.Enqueue(() => Debug.LogError(message));
    }

    private void LogWarningOnMainThread(string message) {
        mainThreadActions.Enqueue(() => Debug.LogWarning(message));
    }

    public void StartServer() {
        try {
            StopServer(); // Ensure any existing server is stopped
            
            cancellationTokenSource = new CancellationTokenSource();
            listener = new TcpListener(IPAddress.Any, port);
            listener.Start();
            running = true;
            LogOnMainThread($"Server started on port {port}");

            listenThread = new Thread(() => ListenLoop(cancellationTokenSource.Token));
            listenThread.IsBackground = true;
            listenThread.Start();
        } catch (Exception ex) {
            LogErrorOnMainThread($"Failed to start server: {ex.Message}");
        }
    }

    private ListenLoop(CancellationToken token) {
        while (running && !token.IsCancellationRequested) {
            TcpClient client = null;
            try {
                // Create an accepting task with timeout
                var asyncResult = listener.BeginAcceptTcpClient(null, null);
                
                // Wait for either a client connection or cancellation
                while (!asyncResult.IsCompleted && !token.IsCancellationRequested) {
                    Thread.Sleep(100);
                }
                
                // If we're cancelled, exit
                if (token.IsCancellationRequested)
                    break;
                
                if (asyncResult.IsCompleted) {
                    client = listener.EndAcceptTcpClient(asyncResult);
                    clients.Add(client);
                    lastAcceptTime = DateTime.Now;
                    LogOnMainThread("Client connected");

                    // Handle client in a separate thread
                    ThreadPool.QueueUserWorkItem(HandleClient, new ClientState 
                    { 
                        Client = client,
                        CancellationToken = token
                    });
                }
            } catch (SocketException) {
                // This can occur when the listener is stopped
                break;
            } catch (ObjectDisposedException) {
                // This can occur when the listener is stopped
                break;
            } catch (Exception ex) {
                LogErrorOnMainThread($"Listener error: {ex.Message}");
                Thread.Sleep(1000); // Avoid tight error loop
            }
        }
    }

    private class ClientState {
        public TcpClient Client { get; set; }
        public CancellationToken CancellationToken { get; set; }
    }

    private void HandleClient(object state) {
        var clientState = (ClientState)state;
        var client = clientState.Client;
        var token = clientState.CancellationToken;
        
        try {
            var stream = client.GetStream();
            using var reader = new StreamReader(stream, Encoding.UTF8);
            using var writer = new StreamWriter(stream, Encoding.UTF8) { AutoFlush = true };

            writer.WriteLine("Welcome to DodgeALL Echo Server!");

            string line;
            while (!token.IsCancellationRequested && client.Connected && (line = reader.ReadLine()) != null) {
                LogOnMainThread("Received: " + line);
                writer.WriteLine("Echo: " + line);
            }
        } catch (IOException) {
            // Client disconnected
        } catch (Exception ex) {
            LogErrorOnMainThread($"Error handling client: {ex.Message}");
        } finally {
            try {
                // Remove the client and clean up
                ((ICollection<TcpClient>)clients).Remove(client);
                client.Close();
                LogOnMainThread("Client disconnected");
            } catch (Exception ex) {
                LogErrorOnMainThread($"Error closing client: {ex.Message}");
            }
        }
    }

    private void Heartbeat() {
        if (!running) {
            LogWarningOnMainThread("Listener not running — restarting...");
            StopServer();
            StartServer();
            return;
        }

        LogOnMainThread("Still listening on port " + port);

        if ((DateTime.Now - lastAcceptTime).TotalMinutes > 5) {
            LogOnMainThread("No connections in a while. Restarting just in case...");
            StopServer();
            StartServer();
        }
    }

    private void StopServer() {
        try {
            running = false;
            
            // Signal the thread to stop
            if (cancellationTokenSource != null) {
                cancellationTokenSource.Cancel();
                cancellationTokenSource.Dispose();
                cancellationTokenSource = null;
            }
            
            // Close the listener
            if (listener != null) {
                listener.Stop();
                listener = null;
            }

            // Close all clients
            foreach (var client in clients) {
                try {
                    client.Close();
                } catch { /* Ignore errors during cleanup */ }
            }
            
            clients = new ConcurrentBag<TcpClient>();
            
            // Give thread time to finish
            if (listenThread != null && listenThread.IsAlive) {
                listenThread.Join(1000);
            }
            listenThread = null;
        } catch (Exception ex) {
            Debug.LogError("Error stopping server: " + ex.Message);
        }
    }

    private void OnApplicationQuit() {
        StopServer();
    }

    private void OnDisable() {
        StopServer();
    }
}

[alec1o]

👋 I'm I moved my sockets to be async by using Socket.ReceiveAsync. But now I'm trying to use single thread on server-side to handle this async operation. all async operation is non-block, and if use one Thread to handle all receive, I needs 2 threads on server, 1 for accept, another one to dispatch async Receive events.

• '_parallelism' is new 'thread' when client side.
• '_parallelism' is shared '_parallelism' object when 'server-side client'

Ideally: is adding task to this single thread dispatch, if works, mean i can handle thousands of sockets and receive thousands of message per seconds using only single dedicated thread. but impl. of 'NetlyEnvironment.Parallelism (internal class)' is going complex.

• "multithreading is hard 😢"

_client._parallelism.Add(Receive);

return;

async Task Receive()
{
    while (IsOpened)
    {
        try
        {
            var size = IsEncrypted
                ? await _sslStream.ReadAsync(buffer, 0, buffer.Length)
                : await _netStream.ReadAsync(buffer, 0, buffer.Length);

            if (size <= 0) break;

            var bytes = new byte[size];
            Buffer.BlockCopy(buffer, 0, bytes, 0, bytes.Length);

            if (IsFraming)
                framing.Add(bytes);
            else
                PushResult(ref bytes);
        }
        catch (Exception e)
        {
            // IsOpened - will detect if it needs close or not.
            NetlyEnvironment.Logger.Create(e);
        }
    }

    _ = Close();
}

[glenneroo]

Yes, I think nobody enjoys multi-threaded programming, especially with Unity. Also every OS handles threads in a different way...

Do you have an Android device to test with? I can try to test later but I might need a couple days before I have time. I can also test iOS (Mac Mini M4 + iPhone 13) if you can make it work on Android.

[alec1o]

Yes!
I have:

• Android (12);
• Windows (11);
• MacBook Pro Mid 2012 (Catalina);
• ❌ but no one, iOS (I'll ask you to test on iOS 👍 )