Skip to content
Merged
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension


Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
14 changes: 14 additions & 0 deletions tools/CloseTiming/CloseTiming.csproj
Original file line number Diff line number Diff line change
@@ -0,0 +1,14 @@
<Project Sdk="Microsoft.NET.Sdk">

<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net8.0</TargetFramework>
<Nullable>disable</Nullable>
<ImplicitUsings>enable</ImplicitUsings>
</PropertyGroup>

<ItemGroup>
<ProjectReference Include="../../websocket-sharp/websocket-sharp-netstandard/altwebsocket-sharp.csproj" />
</ItemGroup>

</Project>
147 changes: 147 additions & 0 deletions tools/CloseTiming/Program.cs
Original file line number Diff line number Diff line change
@@ -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<byte>(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<byte>(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<Holder> 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<Holder>(TaskCreationOptions.RunContinuationsAsynchronously);
server.AddWebSocketService<Holder>("/");
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<byte>(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;
}
}
62 changes: 53 additions & 9 deletions websocket-sharp/websocket-sharp/WebSocket.cs
Original file line number Diff line number Diff line change
Expand Up @@ -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;
Expand All @@ -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);
}


Expand Down
Loading