From e098351bae9d47362fe66437f3700d8b1022f5a7 Mon Sep 17 00:00:00 2001 From: Andre Hofmeister <9199345+HofmeisterAn@users.noreply.github.com> Date: Sat, 31 Oct 2026 08:10:57 +0100 Subject: [PATCH 1/2] fix: Support half-close on native transport hijacked streams --- .../Docker.DotNet.Handler.Abstractions.csproj | 3 + .../HijackScope.cs | 61 +++++++++++++++ .../Properties/InternalVisibleTo.cs | 2 + .../Docker.DotNet.NativeHttp.csproj | 1 + .../DockerHandlerFactory.cs | 28 ++++++- .../TrackingNetworkStream.cs | 76 +++++++++++++++++++ .../WriteClosableStreamWrapper.cs | 16 +++- src/Docker.DotNet/DockerClient.cs | 4 + .../Properties/InternalVisibleTo.cs | 6 +- .../IContainerOperationsTests.cs | 38 ++++++++++ 10 files changed, 228 insertions(+), 7 deletions(-) create mode 100644 src/Docker.DotNet.Handler.Abstractions/HijackScope.cs create mode 100644 src/Docker.DotNet.Handler.Abstractions/Properties/InternalVisibleTo.cs create mode 100644 src/Docker.DotNet.NativeHttp/TrackingNetworkStream.cs diff --git a/src/Docker.DotNet.Handler.Abstractions/Docker.DotNet.Handler.Abstractions.csproj b/src/Docker.DotNet.Handler.Abstractions/Docker.DotNet.Handler.Abstractions.csproj index 5ba5c828..a28df7c0 100644 --- a/src/Docker.DotNet.Handler.Abstractions/Docker.DotNet.Handler.Abstractions.csproj +++ b/src/Docker.DotNet.Handler.Abstractions/Docker.DotNet.Handler.Abstractions.csproj @@ -12,6 +12,9 @@ + + + diff --git a/src/Docker.DotNet.Handler.Abstractions/HijackScope.cs b/src/Docker.DotNet.Handler.Abstractions/HijackScope.cs new file mode 100644 index 00000000..be2db46d --- /dev/null +++ b/src/Docker.DotNet.Handler.Abstractions/HijackScope.cs @@ -0,0 +1,61 @@ +namespace Docker.DotNet.Handler.Abstractions; + +/// +/// Tracks the socket of the connection that carries a hijacked stream. +/// +/// +/// The client begins a scope before it sends a request whose connection it +/// hijacks. A transport that owns its sockets tracks the socket the request is +/// written to, so it can close only the write side of the hijacked stream. +/// +internal sealed class HijackScope : IDisposable +{ + private static readonly AsyncLocal CurrentScope = new(); + + private HijackScope() + { + } + + /// + /// Gets the scope of the current asynchronous control flow, or + /// if none was begun. + /// + public static HijackScope? Current + => CurrentScope.Value; + + /// + /// Gets the socket the request was last written to, or + /// if none was tracked. + /// + public Socket? Socket { get; private set; } + + /// + /// Begins a scope for the current asynchronous control flow. + /// + /// The scope, which ends when it is disposed. + public static HijackScope Begin() + { + var scope = new HijackScope(); + CurrentScope.Value = scope; + return scope; + } + + /// + /// Tracks the socket the request is written to. + /// + /// The socket. + /// + /// The last tracked socket wins, because a request that fails + /// on a pooled connection is retried on a new one. + /// + public void TrackSocket(Socket socket) + { + Socket = socket; + } + + /// + public void Dispose() + { + CurrentScope.Value = null; + } +} \ No newline at end of file diff --git a/src/Docker.DotNet.Handler.Abstractions/Properties/InternalVisibleTo.cs b/src/Docker.DotNet.Handler.Abstractions/Properties/InternalVisibleTo.cs new file mode 100644 index 00000000..36e743ed --- /dev/null +++ b/src/Docker.DotNet.Handler.Abstractions/Properties/InternalVisibleTo.cs @@ -0,0 +1,2 @@ +[assembly: InternalsVisibleTo("Docker.DotNet" + StrongNamePublicKeys.DockerDotNetPublicKey)] +[assembly: InternalsVisibleTo("Docker.DotNet.NativeHttp" + StrongNamePublicKeys.DockerDotNetPublicKey)] \ No newline at end of file diff --git a/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj b/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj index 600e02a5..aa861674 100644 --- a/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj +++ b/src/Docker.DotNet.NativeHttp/Docker.DotNet.NativeHttp.csproj @@ -15,6 +15,7 @@ + diff --git a/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs b/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs index 29cf1869..86bc8e04 100644 --- a/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs +++ b/src/Docker.DotNet.NativeHttp/DockerHandlerFactory.cs @@ -38,6 +38,7 @@ public ResolvedTransport CreateHandler(NativeHttpTransportOptions transportOptio MaxConnectionsPerServer = MaxConnectionsPerServer, PooledConnectionLifetime = PooledConnectionLifetime, PooledConnectionIdleTimeout = PooledConnectionIdleTimeout, + PlaintextStreamFilter = TrackingNetworkStream.EnableTrackingAsync, }; if (IsUnixSocket(uri)) @@ -48,11 +49,12 @@ public ResolvedTransport CreateHandler(NativeHttpTransportOptions transportOptio // Proxies do not apply to Unix domain sockets. handler.UseProxy = false; - handler.ConnectCallback = (_, cancellationToken) => ConnectUnixSocketAsync(socketPath, cancellationToken); + handler.ConnectCallback = (context, cancellationToken) => ConnectUnixSocketAsync(context, socketPath, cancellationToken); } else { uri = CreateHttpUri(uri, clientOptions); + handler.ConnectCallback = ConnectTcpSocketAsync; } transportOptions.ConfigureHandler(handler); @@ -70,7 +72,7 @@ public async Task HijackStreamAsync(HttpContent content) var stream = await content.ReadAsStreamAsync() .ConfigureAwait(false); - return new WriteClosableStreamWrapper(stream); + return new WriteClosableStreamWrapper(stream, HijackScope.Current?.Socket); } private static void Validate(Uri endpoint) @@ -102,7 +104,7 @@ private static bool IsUnixSocket(Uri endpoint) return string.Equals(endpoint.Scheme, "unix", StringComparison.OrdinalIgnoreCase); } - private static async ValueTask ConnectUnixSocketAsync(string socketPath, CancellationToken cancellationToken) + private static async ValueTask ConnectUnixSocketAsync(SocketsHttpConnectionContext context, string socketPath, CancellationToken cancellationToken) { var socket = new Socket(AddressFamily.Unix, SocketType.Stream, ProtocolType.Unspecified); @@ -111,7 +113,25 @@ private static async ValueTask ConnectUnixSocketAsync(string socketPath, await socket.ConnectAsync(new UnixDomainSocketEndPoint(socketPath), cancellationToken) .ConfigureAwait(false); - return new NetworkStream(socket, ownsSocket: true); + return TrackingNetworkStream.Create(socket, context); + } + catch + { + socket.Dispose(); + throw; + } + } + + private static async ValueTask ConnectTcpSocketAsync(SocketsHttpConnectionContext context, CancellationToken cancellationToken) + { + var socket = new Socket(SocketType.Stream, ProtocolType.Tcp) { NoDelay = true }; + + try + { + await socket.ConnectAsync(context.DnsEndPoint, cancellationToken) + .ConfigureAwait(false); + + return TrackingNetworkStream.Create(socket, context); } catch { diff --git a/src/Docker.DotNet.NativeHttp/TrackingNetworkStream.cs b/src/Docker.DotNet.NativeHttp/TrackingNetworkStream.cs new file mode 100644 index 00000000..c52a6610 --- /dev/null +++ b/src/Docker.DotNet.NativeHttp/TrackingNetworkStream.cs @@ -0,0 +1,76 @@ +#if NET +namespace Docker.DotNet.NativeHttp; + +// SocketsHttpHandler does not expose the socket of an upgraded connection, so its +// hijacked stream cannot close only its write side. As a workaround, this stream +// records its socket in the current HijackScope when a hijack request is written to +// it, which relies on SocketsHttpHandler writing a request in the asynchronous +// control flow of the caller. A cleaner solution would send hijack requests through +// a minimal HTTP/1.1 client of its own, like the legacy transport, but that client +// would need its own TLS, proxy, and authentication handling. +internal sealed class TrackingNetworkStream : NetworkStream +{ + private static readonly ConditionalWeakTable PendingStreams = new(); + + private volatile bool _isTrackingEnabled; + + private TrackingNetworkStream(Socket socket) + : base(socket, ownsSocket: true) + { + } + + public static Stream Create(Socket socket, SocketsHttpConnectionContext context) + { + var stream = new TrackingNetworkStream(socket); + PendingStreams.AddOrUpdate(context.InitialRequestMessage, stream); + return stream; + } + + public static ValueTask EnableTrackingAsync(SocketsHttpPlaintextStreamFilterContext context, CancellationToken cancellationToken) + { + // The plaintext stream filter runs once the connection is set up, + // after the TLS handshake. + if (PendingStreams.TryGetValue(context.InitialRequestMessage, out var stream)) + { + PendingStreams.Remove(context.InitialRequestMessage); + stream._isTrackingEnabled = true; + } + + return new ValueTask(context.PlaintextStream); + } + + public override void Write(byte[] buffer, int offset, int count) + { + TrackSocket(); + base.Write(buffer, offset, count); + } + + public override void Write(ReadOnlySpan buffer) + { + TrackSocket(); + base.Write(buffer); + } + + public override Task WriteAsync(byte[] buffer, int offset, int count, CancellationToken cancellationToken) + { + TrackSocket(); + return base.WriteAsync(buffer, offset, count, cancellationToken); + } + + public override ValueTask WriteAsync(ReadOnlyMemory buffer, CancellationToken cancellationToken = default) + { + TrackSocket(); + return base.WriteAsync(buffer, cancellationToken); + } + + private void TrackSocket() + { + // The connection setup runs in the scope of the request that started it, even + // if that request is sent over another connection, so setup writes do not count. + if (_isTrackingEnabled) + { + HijackScope.Current?.TrackSocket(Socket); + } + } +} +#endif \ No newline at end of file diff --git a/src/Docker.DotNet.NativeHttp/WriteClosableStreamWrapper.cs b/src/Docker.DotNet.NativeHttp/WriteClosableStreamWrapper.cs index 2ccf1564..24a79f5d 100644 --- a/src/Docker.DotNet.NativeHttp/WriteClosableStreamWrapper.cs +++ b/src/Docker.DotNet.NativeHttp/WriteClosableStreamWrapper.cs @@ -1,9 +1,11 @@ namespace Docker.DotNet.NativeHttp; -internal sealed class WriteClosableStreamWrapper(Stream stream) : WriteClosableStream +internal sealed class WriteClosableStreamWrapper(Stream stream, Socket? socket) : WriteClosableStream { private readonly Stream _stream = stream ?? throw new ArgumentNullException(nameof(stream)); + private readonly Socket? _socket = socket; + public override bool CanRead => _stream.CanRead; @@ -41,7 +43,17 @@ public override void Write(byte[] buffer, int offset, int count) => _stream.Write(buffer, offset, count); public override void CloseWrite() - => _stream.Close(); + { + if (_socket != null) + { + // Send buffered data before closing the write side of the socket. + _stream.Flush(); + _socket.Shutdown(SocketShutdown.Send); + return; + } + + _stream.Close(); + } protected override void Dispose(bool disposing) { diff --git a/src/Docker.DotNet/DockerClient.cs b/src/Docker.DotNet/DockerClient.cs index 097bae7c..3fc990f2 100644 --- a/src/Docker.DotNet/DockerClient.cs +++ b/src/Docker.DotNet/DockerClient.cs @@ -337,6 +337,10 @@ internal async Task MakeRequestForHijackedStreamAsync( headers.Add("Upgrade", "tcp"); headers.Add("Connection", "upgrade"); + // Lets the transport track the socket of the hijacked connection, + // so the stream can close only its write side. + using var hijackScope = HijackScope.Begin(); + var response = await PrivateMakeRequestAsync(timeout, HttpCompletionOption.ResponseHeadersRead, method, path, queryString, headers, body, cancellationToken) .ConfigureAwait(false); diff --git a/src/Docker.DotNet/Properties/InternalVisibleTo.cs b/src/Docker.DotNet/Properties/InternalVisibleTo.cs index 002ad298..54cea42a 100644 --- a/src/Docker.DotNet/Properties/InternalVisibleTo.cs +++ b/src/Docker.DotNet/Properties/InternalVisibleTo.cs @@ -1 +1,5 @@ -[assembly: InternalsVisibleTo("Docker.DotNet.Tests" + StrongNamePublicKeys.DockerDotNetPublicKey)] \ No newline at end of file +// Docker.DotNet.Handler.Abstractions exposes its own copy of StrongNamePublicKeys +// through InternalsVisibleTo, which conflicts with the copy compiled in here. +#pragma warning disable CS0436 +[assembly: InternalsVisibleTo("Docker.DotNet.Tests" + StrongNamePublicKeys.DockerDotNetPublicKey)] +#pragma warning restore CS0436 \ No newline at end of file diff --git a/test/Docker.DotNet.Tests/IContainerOperationsTests.cs b/test/Docker.DotNet.Tests/IContainerOperationsTests.cs index c2e36892..147e26d4 100644 --- a/test/Docker.DotNet.Tests/IContainerOperationsTests.cs +++ b/test/Docker.DotNet.Tests/IContainerOperationsTests.cs @@ -778,4 +778,42 @@ public async Task WriteAsync_OnMultiplexedStream_ForwardsInputToExecStdin_Comple Assert.Equal(0, containerExecInspectResponse.ExitCode); Assert.Equal("Done\n", stdout); } + + [Fact] + public async Task CloseWrite_OnMultiplexedStream_ClosesExecStdin_CompletesExecProcess() + { + // Given + var inputBytes = Encoding.ASCII.GetBytes("Done\n"); + + var createContainerParameters = new CreateContainerParameters(); + createContainerParameters.Image = _testFixture.Image.ID; + createContainerParameters.Entrypoint = CommonCommands.SleepInfinity; + + var containerExecCreateParameters = new ContainerExecCreateParameters(); + containerExecCreateParameters.AttachStdout = true; + containerExecCreateParameters.AttachStderr = true; + containerExecCreateParameters.AttachStdin = true; + containerExecCreateParameters.Cmd = new[] { "cat" }; + + var containerExecStartParameters = new ContainerExecStartParameters(); + + var createContainerResponse = await _testFixture.DockerClient.Containers.CreateContainerAsync(createContainerParameters, TestContext.Current.CancellationToken); + _ = await _testFixture.DockerClient.Containers.StartContainerAsync(createContainerResponse.ID, new ContainerStartParameters(), TestContext.Current.CancellationToken); + + // When + var containerExecCreateResponse = await _testFixture.DockerClient.Exec.CreateContainerExecAsync(createContainerResponse.ID, containerExecCreateParameters, TestContext.Current.CancellationToken); + using var stream = await _testFixture.DockerClient.Exec.StartContainerExecAsync(containerExecCreateResponse.ID, containerExecStartParameters, TestContext.Current.CancellationToken); + + await stream.WriteAsync(inputBytes, 0, inputBytes.Length, _testFixture.Cts.Token); + stream.CloseWrite(); + + using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(5)); + var (stdout, _) = await stream.ReadOutputToEndAsync(cts.Token); + + var containerExecInspectResponse = await _testFixture.DockerClient.Exec.InspectContainerExecAsync(containerExecCreateResponse.ID, _testFixture.Cts.Token); + + // Then + Assert.Equal(0, containerExecInspectResponse.ExitCode); + Assert.Equal("Done\n", stdout); + } } \ No newline at end of file From 6938bc49adb3fc7e9f7be771c467c8d3da26f9c4 Mon Sep 17 00:00:00 2001 From: Andre Hofmeister <9199345+HofmeisterAn@users.noreply.github.com> Date: Sat, 31 Oct 2026 19:03:43 +0100 Subject: [PATCH 2/2] chore: Replace StrongNamePublicKeys with InternalsVisibleTo items --- Directory.Build.props | 6 ++---- StrongNamePublicKeys.cs | 10 ---------- .../Docker.DotNet.Handler.Abstractions.csproj | 5 ++++- .../Properties/InternalVisibleTo.cs | 2 -- src/Docker.DotNet/Docker.DotNet.csproj | 3 +++ src/Docker.DotNet/Properties/InternalVisibleTo.cs | 5 ----- 6 files changed, 9 insertions(+), 22 deletions(-) delete mode 100644 StrongNamePublicKeys.cs delete mode 100644 src/Docker.DotNet.Handler.Abstractions/Properties/InternalVisibleTo.cs delete mode 100644 src/Docker.DotNet/Properties/InternalVisibleTo.cs diff --git a/Directory.Build.props b/Directory.Build.props index bdb157e8..545a1b94 100644 --- a/Directory.Build.props +++ b/Directory.Build.props @@ -8,9 +8,7 @@ embedded true $(MSBuildThisFileDirectory)\Key.snk + + 002400000480000094000000060200000024000052534131000400000100010013a6d952388480a1ce272e8c8ac11d710668c8723e696a421190445a1e6198288112f5e04eb99a626f8bb1454cdf30ebfb0a09cb7fc7b299cb03aa6fea1ae9a58f05f9fb92a85ce82ad4490bb2f0074822d8b0a786684f26a6eb1765f9026dae4857925b4e077d04b6311bec7dacf8e8a031dcc9f7e0384bca914256abee25d9 - - - - \ No newline at end of file diff --git a/StrongNamePublicKeys.cs b/StrongNamePublicKeys.cs deleted file mode 100644 index 58566321..00000000 --- a/StrongNamePublicKeys.cs +++ /dev/null @@ -1,10 +0,0 @@ -/// -/// Contains the repo identity public key when strong naming the assembly. -/// -internal static class StrongNamePublicKeys -{ - /// - /// The public key used for assemblies in this repo (Key.snk). - /// - public const string DockerDotNetPublicKey = ", PublicKey=002400000480000094000000060200000024000052534131000400000100010013a6d952388480a1ce272e8c8ac11d710668c8723e696a421190445a1e6198288112f5e04eb99a626f8bb1454cdf30ebfb0a09cb7fc7b299cb03aa6fea1ae9a58f05f9fb92a85ce82ad4490bb2f0074822d8b0a786684f26a6eb1765f9026dae4857925b4e077d04b6311bec7dacf8e8a031dcc9f7e0384bca914256abee25d9"; -} \ No newline at end of file diff --git a/src/Docker.DotNet.Handler.Abstractions/Docker.DotNet.Handler.Abstractions.csproj b/src/Docker.DotNet.Handler.Abstractions/Docker.DotNet.Handler.Abstractions.csproj index a28df7c0..d7b6cd3f 100644 --- a/src/Docker.DotNet.Handler.Abstractions/Docker.DotNet.Handler.Abstractions.csproj +++ b/src/Docker.DotNet.Handler.Abstractions/Docker.DotNet.Handler.Abstractions.csproj @@ -7,13 +7,16 @@ + + + + - diff --git a/src/Docker.DotNet.Handler.Abstractions/Properties/InternalVisibleTo.cs b/src/Docker.DotNet.Handler.Abstractions/Properties/InternalVisibleTo.cs deleted file mode 100644 index 36e743ed..00000000 --- a/src/Docker.DotNet.Handler.Abstractions/Properties/InternalVisibleTo.cs +++ /dev/null @@ -1,2 +0,0 @@ -[assembly: InternalsVisibleTo("Docker.DotNet" + StrongNamePublicKeys.DockerDotNetPublicKey)] -[assembly: InternalsVisibleTo("Docker.DotNet.NativeHttp" + StrongNamePublicKeys.DockerDotNetPublicKey)] \ No newline at end of file diff --git a/src/Docker.DotNet/Docker.DotNet.csproj b/src/Docker.DotNet/Docker.DotNet.csproj index 2e9ef442..06b038af 100644 --- a/src/Docker.DotNet/Docker.DotNet.csproj +++ b/src/Docker.DotNet/Docker.DotNet.csproj @@ -23,6 +23,9 @@ + + + diff --git a/src/Docker.DotNet/Properties/InternalVisibleTo.cs b/src/Docker.DotNet/Properties/InternalVisibleTo.cs deleted file mode 100644 index 54cea42a..00000000 --- a/src/Docker.DotNet/Properties/InternalVisibleTo.cs +++ /dev/null @@ -1,5 +0,0 @@ -// Docker.DotNet.Handler.Abstractions exposes its own copy of StrongNamePublicKeys -// through InternalsVisibleTo, which conflicts with the copy compiled in here. -#pragma warning disable CS0436 -[assembly: InternalsVisibleTo("Docker.DotNet.Tests" + StrongNamePublicKeys.DockerDotNetPublicKey)] -#pragma warning restore CS0436 \ No newline at end of file