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 5ba5c828..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,11 +7,17 @@ + + + + + + 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.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/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/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 deleted file mode 100644 index 002ad298..00000000 --- a/src/Docker.DotNet/Properties/InternalVisibleTo.cs +++ /dev/null @@ -1 +0,0 @@ -[assembly: InternalsVisibleTo("Docker.DotNet.Tests" + StrongNamePublicKeys.DockerDotNetPublicKey)] \ 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