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);
}