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