diff --git a/tools/CloseTiming/CloseTiming.csproj b/tools/CloseTiming/CloseTiming.csproj new file mode 100644 index 000000000..429f715fe --- /dev/null +++ b/tools/CloseTiming/CloseTiming.csproj @@ -0,0 +1,14 @@ + + + + Exe + net8.0 + disable + enable + + + + + + + diff --git a/tools/CloseTiming/Program.cs b/tools/CloseTiming/Program.cs new file mode 100644 index 000000000..432995c5e --- /dev/null +++ b/tools/CloseTiming/Program.cs @@ -0,0 +1,147 @@ +// Measures how long AltWebSocketSharp takes to close a connection when the +// peer answers the close frame promptly. A healthy close takes a few ms; the +// bug this harness was written for made every close wait the full 5 s timeout. +// +// Usage: dotnet run -c Release --project tools/CloseTiming [iterations] +// Exit code 1 if any close takes 1 s or longer. + +using System.Diagnostics; +using System.Net; +using System.Net.Sockets; +using AltWebSocketSharp; +using AltWebSocketSharp.Server; +using NetClientWebSocket = System.Net.WebSockets.ClientWebSocket; +using NetWebSocketCloseStatus = System.Net.WebSockets.WebSocketCloseStatus; +using NetWebSocketMessageType = System.Net.WebSockets.WebSocketMessageType; + +static class Program +{ + const long LimitMs = 1000; + const int InFlightDelayMs = 300; + + static int Main(string[] args) + { + var iterations = args.Length > 0 ? int.Parse(args[0]) : 3; + var failed = false; + + for (var i = 1; i <= iterations; i++) + { + var (clientMs, clean) = ClientCloseAgainstSystemNetServer(0); + var (inFlightMs, inFlightClean) = ClientCloseAgainstSystemNetServer(InFlightDelayMs); + var serverMs = ServerCloseAgainstSystemNetClient(); + Console.WriteLine($"run {i}: ClientWebSocket.Close() = {clientMs} ms (WasClean={clean}), server-side session close = {serverMs} ms, Close() with a data frame before a {InFlightDelayMs} ms-late close reply = {inFlightMs} ms (WasClean={inFlightClean})"); + failed |= clientMs >= LimitMs || serverMs >= LimitMs || !clean; + // Close() must wait for the real close reply, not return on the data frame. + failed |= inFlightMs < InFlightDelayMs - 50 || inFlightMs >= LimitMs || !inFlightClean; + } + + Console.WriteLine(failed ? "FAIL: see the timings above" : "OK: every close took < 1000 ms, client closes were clean, and Close() waited for the real close reply"); + return failed ? 1 : 0; + } + + static int FreePort() + { + var l = new TcpListener(IPAddress.Loopback, 0); + l.Start(); + var port = ((IPEndPoint)l.LocalEndpoint).Port; + l.Stop(); + return port; + } + + // AltWebSocketSharp.ClientWebSocket closes against a System.Net.WebSockets + // server that echoes the close frame. With replyDelayMs > 0 the server + // first sends a data frame and only replies to the close after that delay. + static (long ms, bool wasClean) ClientCloseAgainstSystemNetServer(int replyDelayMs) + { + var port = FreePort(); + var prefix = $"http://127.0.0.1:{port}/"; + using var listener = new HttpListener(); + listener.Prefixes.Add(prefix); + listener.Start(); + + var serverTask = Task.Run(async () => + { + var ctx = await listener.GetContextAsync(); + var wsCtx = await ctx.AcceptWebSocketAsync(null); + var ws = wsCtx.WebSocket; + var buffer = new byte[1024]; + while (true) + { + var result = await ws.ReceiveAsync(new ArraySegment(buffer), CancellationToken.None); + if (result.MessageType == NetWebSocketMessageType.Close) + { + if (replyDelayMs > 0) + { + var data = System.Text.Encoding.UTF8.GetBytes("in flight"); + await ws.SendAsync(new ArraySegment(data), NetWebSocketMessageType.Text, true, CancellationToken.None); + await Task.Delay(replyDelayMs); + } + await ws.CloseOutputAsync(NetWebSocketCloseStatus.NormalClosure, "", CancellationToken.None); + break; + } + } + }); + + var client = new ClientWebSocket($"ws://127.0.0.1:{port}/"); + client.Log.Level = LogLevel.Fatal; + var wasClean = false; + client.OnClose += (_, e) => wasClean = e.WasClean; + client.Connect(); + if (client.ReadyState != WebSocketState.Open) + throw new Exception("client did not connect"); + + var sw = Stopwatch.StartNew(); + client.Close(); + sw.Stop(); + + try { serverTask.Wait(TimeSpan.FromSeconds(10)); } catch (AggregateException) { } + listener.Stop(); + return (sw.ElapsedMilliseconds, wasClean); + } + + class Holder : WebSocketBehavior + { + public static TaskCompletionSource Opened; + public void CloseFromServer() => Sessions.CloseSession(ID); + protected override void OnOpen() => Opened.TrySetResult(this); + } + + // AltWebSocketSharp.Server closes a session against a System.Net.WebSockets + // client that answers the close frame as soon as it receives it. + static long ServerCloseAgainstSystemNetClient() + { + var port = FreePort(); + var server = new WebSocketServer($"ws://127.0.0.1:{port}"); + server.Log.Level = LogLevel.Fatal; + Holder.Opened = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + server.AddWebSocketService("/"); + server.Start(); + + using var client = new NetClientWebSocket(); + client.ConnectAsync(new Uri($"ws://127.0.0.1:{port}/"), CancellationToken.None).Wait(); + var clientTask = Task.Run(async () => + { + var buffer = new byte[1024]; + while (client.State == System.Net.WebSockets.WebSocketState.Open) + { + var result = await client.ReceiveAsync(new ArraySegment(buffer), CancellationToken.None); + if (result.MessageType == NetWebSocketMessageType.Close) + { + // ReceiveAsync does not answer a close frame; send the reply. + await client.CloseOutputAsync(NetWebSocketCloseStatus.NormalClosure, "", CancellationToken.None); + break; + } + } + }); + + var holder = Holder.Opened.Task.Result; + var sw = Stopwatch.StartNew(); + holder.CloseFromServer(); + sw.Stop(); + + // The server drops TCP after its close handshake; an EOF here is fine. + try { clientTask.Wait(TimeSpan.FromSeconds(10)); } catch (AggregateException) { } + server.Stop(); + return sw.ElapsedMilliseconds; + } +} diff --git a/websocket-sharp/websocket-sharp/WebSocket.cs b/websocket-sharp/websocket-sharp/WebSocket.cs index 66ade5727..a816d13aa 100644 --- a/websocket-sharp/websocket-sharp/WebSocket.cs +++ b/websocket-sharp/websocket-sharp/WebSocket.cs @@ -1224,27 +1224,63 @@ private void startReceiving() pongReceivedEvent = new ManualResetEvent(false); receivingExitedEvent = new ManualResetEvent(false); - ReceiveLoop(); + ReceiveLoop(socketStream, receivingExitedEvent); } - private void ReceiveLoop() + // The loop keeps its own references to the stream and to the + // receivingExited event. The close sequence clears both fields + // (ReleaseClientResources / ReleaseServerResources and + // ReleaseCommonResources) before CloseHandshake waits on the saved + // event. Signalling the field would never wake the waiting Close(), + // and every close would wait out its full timeout. + // + // The loop signals the event only when a close frame arrives (or + // when processing a frame ends the connection), so a data frame + // that is still in flight during a local close is not mistaken for + // the peer's close reply. + private void ReceiveLoop(Stream stream, ManualResetEvent receivingExited) { + void SignalReceivingExited() + { + try + { + receivingExited?.Set(); + } + catch (ObjectDisposedException) + { + // The close sequence already gave up waiting and disposed it. + } + } + void OnReadCompleted(WebSocketFrame frame) { + if (readyState == WebSocketState.Closed) + { + // A local close is waiting for the peer's close reply. + // Ignore anything else that was already in flight. + if (frame.IsClose) + { + logger.Info("ReceiveLoop exit: close reply received after the local close."); + SignalReceivingExited(); + return; + } + + ReceiveLoop(stream, receivingExited); + return; + } + var receivedFrameResult = ProcessReceivedFrame(frame); - var closed = readyState == WebSocketState.Closed; - if (!receivedFrameResult || closed) + if (!receivedFrameResult) { - logger.Info($"ReceiveLoop exit closed={closed} receivedFrameResult={receivedFrameResult}"); - - receivingExitedEvent?.Set(); + logger.Info("ReceiveLoop exit: the received frame ended the connection."); + SignalReceivingExited(); return; } // Receive next asap because the Ping or Close needs a response to it. - ReceiveLoop(); + ReceiveLoop(stream, receivingExited); if (inMessage || !HasMessage || readyState != WebSocketState.Open) return; @@ -1254,11 +1290,19 @@ void OnReadCompleted(WebSocketFrame frame) void OnReadFailed(Exception ex) { + if (readyState == WebSocketState.Closed) + { + // The close sequence closed the stream (after the handshake + // or its timeout). Nothing is left to report. + logger.Debug("ReceiveLoop exit: the stream was closed after the local close."); + return; + } + logger.Fatal(ex.ToString()); Fatal("An exception has occurred while receiving.", ex); } - WebSocketFrame.ReadFrameAsync(socketStream, false, OnReadCompleted, OnReadFailed); + WebSocketFrame.ReadFrameAsync(stream, false, OnReadCompleted, OnReadFailed); }