diff --git a/src/ioxide/Tls/Pipes/TlsDecryptingPipeReader.cs b/src/ioxide/Tls/Pipes/TlsDecryptingPipeReader.cs index 944c7f9b..b6faf002 100644 --- a/src/ioxide/Tls/Pipes/TlsDecryptingPipeReader.cs +++ b/src/ioxide/Tls/Pipes/TlsDecryptingPipeReader.cs @@ -18,7 +18,11 @@ namespace ioxide.tls; /// consumed/examined bookkeeping a PipeReader owes its caller. The caller's read IS that Pipe's /// read; this class only feeds it. /// -/// A read from another thread takes what is already decrypted there; decrypting and disposal run on the connection's reactor. +/// +/// A read from another thread takes what is already decrypted there; decrypting and disposal run on the connection's +/// reactor. Once the reactor has stopped, such a read reports the end of the stream instead of decrypting what is still +/// queued. +/// public sealed class TlsDecryptingPipeReader : PipeReader, IAsyncDisposable, IRecvListener { private readonly TcpConnection _conn; @@ -91,7 +95,16 @@ public override ValueTask ReadAsync(CancellationToken cancellationTo [MethodImpl(MethodImplOptions.NoInlining)] private async ValueTask FillOnReactor(ValueTask read) { - await new ReactorSwitch(_conn.Reactor); + try + { + await new ReactorSwitch(_conn.Reactor); + } + catch (ObjectDisposedException) + { + // The stop closed the connection and freed the shared receive buffers, which what is queued may point into. + EndClosed(); + return await read; + } if (!read.IsCompleted) { @@ -231,12 +244,14 @@ private bool Ingest(in RecvSnapshot snapshot) } if (closed) { - // An overflow dropped ciphertext: a truncation, so it ends the stream as an error. - End(!_session.Closed && _conn.RecvOverflowed ? TcpConnection.RecvOverflowError() : null); + EndClosed(); } return true; } + // An overflow dropped ciphertext: a truncation, so it ends the stream as an error. + private void EndClosed() => End(!_session.Closed && _conn.RecvOverflowed ? TcpConnection.RecvOverflowError() : null); + // Make what was just decrypted readable. With no pause threshold this never waits. private void Publish() { diff --git a/tests/Ioxide.Tests.Tls/OffReactorFlushTests.cs b/tests/Ioxide.Tests.Tls/OffReactorFlushTests.cs index 853f2eb5..1a6e9d8b 100644 --- a/tests/Ioxide.Tests.Tls/OffReactorFlushTests.cs +++ b/tests/Ioxide.Tests.Tls/OffReactorFlushTests.cs @@ -262,17 +262,35 @@ public static void Register(Runner runner, bool ktls) Assert.True(outcome.Task.Result >= Rounds / 2, $"the handler resumed on the reactor after {outcome.Task.Result} of {Rounds} decrypts"); }); - runner.Test("tls pipe: a read from another thread that has to decrypt fails once the reactor has stopped, instead of waiting forever", () => + runner.Test("tls pipe: a read from another thread that has to decrypt returns completed once the reactor has stopped, instead of throwing", () => { + // Its switch to the reactor threw ObjectDisposedException, where the kTLS RX half reports the connection the stop closed (#585). (string certPath, string keyPath) = TestCert.Ensure(); var options = new TlsOptions { CertificatePath = certPath, KeyPath = keyPath }; - var offReactor = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); - using var stopped = new ManualResetEventSlim(); - var outcome = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + string read = ReadAfterTheStop(options, typeof(TlsDecryptingPipeReader)); + Assert.True(read is "completed" or "completed at once", $"the read after the stop: {read}"); + }); + + runner.Test("tls pipe: control: under kTLS RX a read from another thread once the reactor has stopped returns completed", () => + { + // The connection's own reader, under the prologue reader: it reports the connection the stop closed. + (string certPath, string keyPath) = TestCert.Ensure(); + var options = new TlsOptions { CertificatePath = certPath, KeyPath = keyPath, KernelTx = true, KernelRx = true }; + + string read = ReadAfterTheStop(options, typeof(TlsProloguePipeReader)); + Assert.True(read is "completed" or "completed at once", $"the read after the stop: {read}"); + }, skip: !ktls); + + runner.Test("tls pipe: a read from another thread still queued when the reactor stops returns completed, instead of throwing", () => + { + // Posted before the stop, but after the reactor last ran its posts: the stop handed its switch to the thread pool (#585). + (string certPath, string keyPath) = TestCert.Ensure(); + var options = new TlsOptions { CertificatePath = certPath, KeyPath = keyPath }; + var outcome = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); (int port, Reactor reactor, Thread thread) = TestServer.StartConfigured( - StoppedReadHandler(offReactor, stopped, outcome), + QueuedReadHandler(outcome), new ServerConfig { RecvBufferSize = 4096, RecvSlots = 256, @@ -286,13 +304,51 @@ public static void Register(Runner runner, bool ktls) ssl.AuthenticateAsClient(new SslClientAuthenticationOptions { TargetHost = "localhost" }); ssl.Write(new byte[] { 1 }); - Assert.True(offReactor.Task.Wait(10_000), "the handler never left the reactor"); - reactor.Stop(); - Assert.True(thread.Join(TimeSpan.FromSeconds(10)), "the reactor did not stop"); - stopped.Set(); + // The handler stops the reactor itself, in the pass the read was posted in. + bool stopped = thread.Join(TimeSpan.FromSeconds(10)); + if (!stopped) + { + reactor.Stop(); + } + Assert.True(stopped, $"the handler never stopped the reactor: {(outcome.Task.IsCompleted ? outcome.Task.Result : "no outcome")}"); + + Assert.True(outcome.Task.Wait(20_000), "the handler never reported"); + Assert.Equal("completed", outcome.Task.Result); + }); - Assert.True(outcome.Task.Wait(10_000), "the read never finished, and nothing will ever run it now"); - Assert.Equal("ObjectDisposedException", outcome.Task.Result); + runner.Test("tls pipe: a read from another thread once the reactor has stopped reports a receive-queue overflow before it as an error", () => + { + // The overflow dropped ciphertext, a truncation, which the stop must not turn into a clean end. + (string certPath, string keyPath) = TestCert.Ensure(); + var options = new TlsOptions { CertificatePath = certPath, KeyPath = keyPath }; + + string read = ReadAfterTheStop(options, typeof(TlsDecryptingPipeReader), + new ServerConfig + { + RecvBufferSize = 64, RecvSlots = 256, + Tcp = new TcpOptions { WriteSlabSize = 16 * 1024, PoolMax = 8, RecvQueueEntries = 16 }, + }, + (ssl, connection) => + { + ssl.Write(new byte[4096]); // 64-byte buffers: 65 deliveries into a 16-slot queue + Assert.True(SpinWait.SpinUntil(() => connection.RecvOverflowed, 10_000), "the queue never overflowed"); + }); + Assert.Equal("IOException", read); + }); + + runner.Test("tls pipe: a read from another thread once the reactor has stopped returns completed without decrypting what arrived before the stop", () => + { + // What is queued points into the reactor's receive buffers, which the stop freed. + (string certPath, string keyPath) = TestCert.Ensure(); + var options = new TlsOptions { CertificatePath = certPath, KeyPath = keyPath }; + + string read = ReadAfterTheStop(options, typeof(TlsDecryptingPipeReader), beforeTheStop: (ssl, connection) => + { + ssl.Write(new byte[1000]); + Assert.True(SpinWait.SpinUntil(() => Volatile.Read(ref PendingOf(connection)) == 1, 10_000), + "the client's bytes never reached the connection"); + }); + Assert.True(read is "completed" or "completed at once", $"the read after the stop: {read}"); }); runner.Test("tls pipe: a flush from another thread once the reactor has stopped returns completed, instead of waiting forever", () => @@ -350,6 +406,69 @@ public static void Register(Runner runner, bool ktls) }); } + // The handler leaves the reactor, waits on its own thread until the reactor has stopped, then reads there. + private static string ReadAfterTheStop( + TlsOptions options, Type reader, ServerConfig? config = null, Action? beforeTheStop = null) + { + var offReactor = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + using var stopped = new ManualResetEventSlim(); + var outcome = new TaskCompletionSource(TaskCreationOptions.RunContinuationsAsynchronously); + + (int port, Reactor reactor, Thread thread) = TestServer.StartConfigured( + StoppedReadHandler(reader, offReactor, stopped, outcome), + config ?? new ServerConfig + { + RecvBufferSize = 4096, RecvSlots = 256, + Tcp = new TcpOptions { WriteSlabSize = 16 * 1024, PoolMax = 64, RecvQueueEntries = 64 }, + }, + r => TlsService.Start(r, options)); + + using var tcp = new TcpClient(); + tcp.Connect("127.0.0.1", port); + using var ssl = new SslStream(tcp.GetStream(), leaveInnerStreamOpen: false, (_, _, _, _) => true); + ssl.AuthenticateAsClient(new SslClientAuthenticationOptions { TargetHost = "localhost" }); + ssl.Write(new byte[] { 1 }); + + try + { + Assert.True(offReactor.Task.Wait(10_000), "the handler never left the reactor"); + beforeTheStop?.Invoke(ssl, offReactor.Task.Result); + reactor.Stop(); + Assert.True(thread.Join(TimeSpan.FromSeconds(10)), "the reactor did not stop"); + } + finally + { + stopped.Set(); + } + + Assert.True(outcome.Task.Wait(20_000), "the handler never reported"); + return outcome.Task.Result; + } + + // How a read from another thread ended, told whether it had completed when ReadAsync returned. Left waiting, it is + // "never finished", and nothing will ever run it now. + private static string ReadOutcome(ValueTask read, bool atOnce) + { + Task ended = read.AsTask(); + try + { + if (!ended.Wait(10_000)) + { + return "never finished"; + } + } + catch (AggregateException e) + { + return e.InnerException?.GetType().Name ?? e.GetType().Name; + } + + ReadResult result = ended.Result; + string ending = !result.IsCompleted ? "returned, not completed" + : atOnce ? "completed at once" + : "completed"; + return result.Buffer.IsEmpty ? ending : $"{ending}, with {result.Buffer.Length} bytes"; + } + // Completed, at once or through the thread pool, nothing left staged that nothing would ever send, and the cancel // reported by the flush it was for. private static void AssertFlushedAfterTheStop((string Flushed, long Staged, string Canceled) after) @@ -631,7 +750,7 @@ private static Func DecryptOffReactorHandler(Semap }; private static Func StoppedReadHandler( - TaskCompletionSource offReactor, ManualResetEventSlim stopped, TaskCompletionSource outcome) + Type reader, TaskCompletionSource offReactor, ManualResetEventSlim stopped, TaskCompletionSource outcome) => async (reactor, connection) => { TlsSession? session = null; @@ -653,18 +772,105 @@ private static Func StoppedReadHandler( pipe.Input.AdvanceTo(first.Buffer.End); await Task.Yield(); // leaves the reactor: nothing brings it back - offReactor.TrySetResult(); + offReactor.TrySetResult(connection); stopped.Wait(); + // The half the handshake chose: under the wrong one this would test the other. + if (pipe.Input.GetType() != reader) + { + outcome.TrySetResult($"the session's reader is {pipe.Input.GetType().Name}"); + return; + } + + ValueTask read = pipe.Input.ReadAsync(); + outcome.TrySetResult(ReadOutcome(read, read.IsCompleted)); + } + catch (Exception e) + { + outcome.TrySetResult(e.GetType().Name); + offReactor.TrySetResult(connection); + } + finally + { + if (pipe is not null) + { + await pipe.DisposeAsync(); + } + else + { + session?.Dispose(); + } + connection.DecRef(); + } + }; + + private static Func QueuedReadHandler(TaskCompletionSource outcome) + => async (reactor, connection) => + { + TlsSession? session = null; + TlsConnectionDualPipe? pipe = null; + try + { try { - await pipe.Input.ReadAsync(); - outcome.TrySetResult("the read returned"); + session = await reactor.GetService()!.AcceptAsync(connection); } - catch (Exception e) + catch + { + return; // the harness's readiness probe never completes a handshake + } + + pipe = new TlsConnectionDualPipe(connection, session); + using var posted = new ManualResetEventSlim(); + + // Resumed by the client's byte, among the pass's completions: the pass ran its posts before them. + ReadResult first = await pipe.Input.ReadAsync(); + pipe.Input.AdvanceTo(first.Buffer.End); + + if (pipe.Input is not TlsDecryptingPipeReader) + { + outcome.TrySetResult($"the session's reader is {pipe.Input.GetType().Name}"); + } + else { - outcome.TrySetResult(e.GetType().Name); + // Another thread reads while this holds the reactor, so the read's switch is posted, and the stop then + // ends the loop with this pass: it never runs its posts again. + PipeReader input = pipe.Input; + new Thread(() => + { + ValueTask read; + bool atOnce; + try + { + read = input.ReadAsync(); + atOnce = read.IsCompleted; // while the reactor is held, so nothing else can have completed it + } + catch (Exception e) + { + outcome.TrySetResult(e.GetType().Name); + return; + } + finally + { + posted.Set(); + } + + string ended = ReadOutcome(read, atOnce); + + // Set by the stop's close only with no read parked, and cleared by a read that reaches the connection. + outcome.TrySetResult(Volatile.Read(ref PendingOf(connection)) == 1 + ? ended + : $"{ended}, by a read that reached the connection"); + }) { IsBackground = true, Name = "tls-585-reader" }.Start(); + + if (!posted.Wait(10_000)) + { + outcome.TrySetResult("the reader never read"); + } } + + reactor.Stop(); + await outcome.Task; // the reader must be done with the pipe before it is disposed under it } catch (Exception e) {