[release/7.0-preview7] Update dependencies from dotnet/runtime dotnet/efcore

src/Servers/HttpSys/test/FunctionalTests/Http3Tests.cs

@@ -174,8 +174,9 @@ public async Task Http3_ResetBeforeHeaders()
  client.DefaultRequestVersion = HttpVersion.Version30;
  client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionExact;
  var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address));
- var qex = Assert.IsType<QuicStreamAbortedException>(ex.InnerException);
- Assert.Equal(0x010b, qex.ErrorCode);
+ var qex = Assert.IsType<QuicException>(ex.InnerException);
+ Assert.Equal(QuicError.StreamAborted, qex.QuicError);
+ Assert.Equal(0x010b, qex.ApplicationErrorCode.Value);
  }
 
  [ConditionalFact]
@@ -206,8 +207,9 @@ public async Task Http3_ResetAfterHeaders()
  headersReceived.SetResult();
  response.EnsureSuccessStatusCode();
  var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync());
- var qex = Assert.IsType<QuicStreamAbortedException>(ex.InnerException?.InnerException?.InnerException);
- Assert.Equal(0x010c, qex.ErrorCode);
+ var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException);
+ Assert.Equal(QuicError.StreamAborted, qex.QuicError);
+ Assert.Equal(0x010c, qex.ApplicationErrorCode.Value);
  }
 
  [ConditionalFact]
@@ -231,8 +233,9 @@ public async Task Http3_AppExceptionAfterHeaders_InternalError()
  headersReceived.SetResult();
  response.EnsureSuccessStatusCode();
  var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync());
- var qex = Assert.IsType<QuicStreamAbortedException>(ex.InnerException?.InnerException?.InnerException);
- Assert.Equal(0x0102, qex.ErrorCode); // H3_INTERNAL_ERROR
+ var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException);
+ Assert.Equal(QuicError.StreamAborted, qex.QuicError);
+ Assert.Equal(0x0102, qex.ApplicationErrorCode.Value); // H3_INTERNAL_ERROR
  }
 
  [ConditionalFact]
@@ -251,7 +254,8 @@ public async Task Http3_Abort_Cancel()
  client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionExact;
 
  var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address));
- var qex = Assert.IsType<QuicStreamAbortedException>(ex.InnerException);
- Assert.Equal(0x010c, qex.ErrorCode); // H3_REQUEST_CANCELLED
+ var qex = Assert.IsType<QuicException>(ex.InnerException);
+ Assert.Equal(QuicError.StreamAborted, qex.QuicError);
+ Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); // H3_REQUEST_CANCELLED
  }
 }

src/Servers/HttpSys/test/FunctionalTests/Microsoft.AspNetCore.Server.HttpSys.FunctionalTests.csproj

@@ -4,6 +4,8 @@
  <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
  <TestGroupName>HttpSys.FunctionalTests</TestGroupName>
  <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ <!-- Required for System.Net.Quic which has a preview API in .NET 7 -->
+ <EnablePreviewFeatures>true</EnablePreviewFeatures>
  </PropertyGroup>
 
  <ItemGroup>

src/Servers/IIS/IIS/test/IIS.FunctionalTests/Http3Tests.cs

@@ -120,8 +120,9 @@ public async Task Http3_ResetBeforeHeaders()
  client.DefaultRequestVersion = HttpVersion.Version30;
  client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionExact;
  var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address));
- var qex = Assert.IsType<QuicStreamAbortedException>(ex.InnerException);
- Assert.Equal(0x010b, qex.ErrorCode);
+ var qex = Assert.IsType<QuicException>(ex.InnerException);
+ Assert.Equal(QuicError.StreamAborted, qex.QuicError);
+ Assert.Equal(0x010b, qex.ApplicationErrorCode.Value);
  }
 
  [ConditionalFact]
@@ -135,8 +136,9 @@ public async Task Http3_ResetAfterHeaders()
  await client.GetAsync(Fixture.Client.BaseAddress.ToString() + "Http3_ResetAfterHeaders_SetResult");
  response.EnsureSuccessStatusCode();
  var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync());
- var qex = Assert.IsType<QuicStreamAbortedException>(ex.InnerException?.InnerException?.InnerException);
- Assert.Equal(0x010c, qex.ErrorCode); // H3_REQUEST_CANCELLED
+ var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException);
+ Assert.Equal(QuicError.StreamAborted, qex.QuicError);
+ Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); // H3_REQUEST_CANCELLED
  }
 
  [ConditionalFact]
@@ -151,8 +153,9 @@ public async Task Http3_AppExceptionAfterHeaders_InternalError()
  await client.GetAsync(Fixture.Client.BaseAddress.ToString() + "Http3_AppExceptionAfterHeaders_InternalError_SetResult");
  response.EnsureSuccessStatusCode();
  var ex = await Assert.ThrowsAsync<HttpRequestException>(() => response.Content.ReadAsStringAsync());
- var qex = Assert.IsType<QuicStreamAbortedException>(ex.InnerException?.InnerException?.InnerException);
- Assert.Equal(0x0102, qex.ErrorCode); // H3_INTERNAL_ERROR
+ var qex = Assert.IsType<QuicException>(ex.InnerException?.InnerException?.InnerException);
+ Assert.Equal(QuicError.StreamAborted, qex.QuicError);
+ Assert.Equal(0x0102, qex.ApplicationErrorCode.Value); // H3_INTERNAL_ERROR
  }
 
  [ConditionalFact]
@@ -164,8 +167,9 @@ public async Task Http3_Abort_Cancel()
  client.DefaultVersionPolicy = HttpVersionPolicy.RequestVersionExact;
 
  var ex = await Assert.ThrowsAsync<HttpRequestException>(() => client.GetAsync(address));
- var qex = Assert.IsType<QuicStreamAbortedException>(ex.InnerException);
- Assert.Equal(0x010c, qex.ErrorCode); // H3_REQUEST_CANCELLED
+ var qex = Assert.IsType<QuicException>(ex.InnerException);
+ Assert.Equal(QuicError.StreamAborted, qex.QuicError);
+ Assert.Equal(0x010c, qex.ApplicationErrorCode.Value); // H3_REQUEST_CANCELLED
  }
 
  private HttpClient SetUpClient()

src/Servers/IIS/IIS/test/IIS.FunctionalTests/IIS.FunctionalTests.csproj

@@ -1,4 +1,4 @@
-<Project Sdk="Microsoft.NET.Sdk">
+<Project Sdk="Microsoft.NET.Sdk">
 
  <PropertyGroup>
  <TargetFramework>$(DefaultNetCoreTargetFramework)</TargetFramework>
@@ -7,6 +7,8 @@
  <DisableFastUpToDateCheck>True</DisableFastUpToDateCheck>
  <SkipTests Condition=" '$(SkipIISTests)' == 'true' ">true</SkipTests>
  <AllowUnsafeBlocks>true</AllowUnsafeBlocks>
+ <!-- Required for System.Net.Quic which has a preview API in .NET 7 -->
+ <EnablePreviewFeatures>true</EnablePreviewFeatures>
  </PropertyGroup>
 
  <Import Project="../FunctionalTest.props" />

src/Servers/IIS/IIS/test/IIS.Shared.FunctionalTests/ApplicationInitializationTests.cs

@@ -56,6 +56,7 @@ await RunTest(baseDeploymentParameters, async result =>
  [RequiresNewHandler]
  [InlineData(HostingModel.InProcess)]
  [InlineData(HostingModel.OutOfProcess)]
+ [QuarantinedTest("https://github.com/dotnet/aspnetcore/issues/42658")]
  public async Task ApplicationInitializationPageIsRequested(HostingModel hostingModel)
  {
  // This test often hits a memory leak in warmup.dll module, it has been reported to IIS team

src/Servers/Kestrel/Core/src/Internal/SniOptionsSelector.cs

@@ -194,6 +194,7 @@ internal static SslServerAuthenticationOptions CloneSslOptions(SslServerAuthenti
  ServerCertificate = sslOptions.ServerCertificate,
  ServerCertificateContext = sslOptions.ServerCertificateContext,
  ServerCertificateSelectionCallback = sslOptions.ServerCertificateSelectionCallback,
+ CertificateChainPolicy = sslOptions.CertificateChainPolicy,
  };
 
  private sealed class SniOptions

src/Servers/Kestrel/Core/test/SniOptionsSelectorTests.cs

@@ -794,6 +794,8 @@ public void CloneSslOptionsClonesAllProperties()
  ServerCertificateContext = SslStreamCertificateContext.Create(_x509Certificate2, additionalCertificates: null, offline: true),
  // Defaults to null
  ServerCertificateSelectionCallback = (sender, serverName) => null,
+ // Defaults to null
+ CertificateChainPolicy = new X509ChainPolicy(),
  };
 
  var clonedOptions = SniOptionsSelector.CloneSslOptions(options);
@@ -836,6 +838,9 @@ public void CloneSslOptionsClonesAllProperties()
  Assert.Same(options.ServerCertificateSelectionCallback, clonedOptions.ServerCertificateSelectionCallback);
  Assert.True(propertyNames.Remove(nameof(options.ServerCertificateSelectionCallback)));
 
+ Assert.Same(options.CertificateChainPolicy, clonedOptions.CertificateChainPolicy);
+ Assert.True(propertyNames.Remove(nameof(options.CertificateChainPolicy)));
+
  // Ensure we've checked every property. When new properties get added, we'll have to update this test along with the CloneSslOptions implementation.
  Assert.Empty(propertyNames);
  }

src/Servers/Kestrel/Kestrel.slnf

@@ -2,17 +2,11 @@
  "solution": {
  "path": "..\\..\\..\\AspNetCore.sln",
  "projects": [
- "src\\DataProtection\\Abstractions\\src\\Microsoft.AspNetCore.DataProtection.Abstractions.csproj",
- "src\\DataProtection\\Cryptography.Internal\\src\\Microsoft.AspNetCore.Cryptography.Internal.csproj",
- "src\\DataProtection\\DataProtection\\src\\Microsoft.AspNetCore.DataProtection.csproj",
- "src\\DefaultBuilder\\src\\Microsoft.AspNetCore.csproj",
  "src\\Extensions\\Features\\src\\Microsoft.Extensions.Features.csproj",
  "src\\Extensions\\Features\\test\\Microsoft.Extensions.Features.Tests.csproj",
  "src\\Hosting\\Abstractions\\src\\Microsoft.AspNetCore.Hosting.Abstractions.csproj",
  "src\\Hosting\\Hosting\\src\\Microsoft.AspNetCore.Hosting.csproj",
  "src\\Hosting\\Server.Abstractions\\src\\Microsoft.AspNetCore.Hosting.Server.Abstractions.csproj",
- "src\\Http\\Authentication.Abstractions\\src\\Microsoft.AspNetCore.Authentication.Abstractions.csproj",
- "src\\Http\\Authentication.Core\\src\\Microsoft.AspNetCore.Authentication.Core.csproj",
  "src\\Http\\Headers\\src\\Microsoft.Net.Http.Headers.csproj",
  "src\\Http\\Http.Abstractions\\src\\Microsoft.AspNetCore.Http.Abstractions.csproj",
  "src\\Http\\Http.Extensions\\src\\Microsoft.AspNetCore.Http.Extensions.csproj",
@@ -27,13 +21,8 @@
  "src\\Middleware\\HostFiltering\\src\\Microsoft.AspNetCore.HostFiltering.csproj",
  "src\\Middleware\\HttpOverrides\\src\\Microsoft.AspNetCore.HttpOverrides.csproj",
  "src\\ObjectPool\\src\\Microsoft.Extensions.ObjectPool.csproj",
- "src\\Security\\Authentication\\Core\\src\\Microsoft.AspNetCore.Authentication.csproj",
  "src\\Security\\Authorization\\Core\\src\\Microsoft.AspNetCore.Authorization.csproj",
- "src\\Security\\Authorization\\Policy\\src\\Microsoft.AspNetCore.Authorization.Policy.csproj",
  "src\\Servers\\Connections.Abstractions\\src\\Microsoft.AspNetCore.Connections.Abstractions.csproj",
- "src\\Servers\\HttpSys\\src\\Microsoft.AspNetCore.Server.HttpSys.csproj",
- "src\\Servers\\IIS\\IISIntegration\\src\\Microsoft.AspNetCore.Server.IISIntegration.csproj",
- "src\\Servers\\IIS\\IIS\\src\\Microsoft.AspNetCore.Server.IIS.csproj",
  "src\\Servers\\Kestrel\\Core\\src\\Microsoft.AspNetCore.Server.Kestrel.Core.csproj",
  "src\\Servers\\Kestrel\\Core\\test\\Microsoft.AspNetCore.Server.Kestrel.Core.Tests.csproj",
  "src\\Servers\\Kestrel\\Kestrel\\src\\Microsoft.AspNetCore.Server.Kestrel.csproj",
@@ -56,8 +45,7 @@
  "src\\Servers\\Kestrel\\test\\Sockets.BindTests\\Sockets.BindTests.csproj",
  "src\\Servers\\Kestrel\\test\\Sockets.FunctionalTests\\Sockets.FunctionalTests.csproj",
  "src\\Servers\\Kestrel\\tools\\CodeGenerator\\CodeGenerator.csproj",
- "src\\Testing\\src\\Microsoft.AspNetCore.Testing.csproj",
- "src\\WebEncoders\\src\\Microsoft.Extensions.WebEncoders.csproj"
+ "src\\Testing\\src\\Microsoft.AspNetCore.Testing.csproj"
  ]
  }
 }

src/Servers/Kestrel/Kestrel/src/WebHostBuilderKestrelExtensions.cs

@@ -29,6 +29,7 @@ public static class WebHostBuilderKestrelExtensions
  public static IWebHostBuilder UseKestrel(this IWebHostBuilder hostBuilder)
  {
  hostBuilder.UseQuic();
+
  return hostBuilder.ConfigureServices(services =>
  {
  // Don't override an already-configured transport

src/Servers/Kestrel/Transport.Quic/src/Internal/QuicConnectionContext.cs

@@ -65,7 +65,7 @@ public override async ValueTask DisposeAsync()
  _log.LogWarning(ex, "Failed to gracefully shutdown connection.");
  }
 
- _connection.Dispose();
+ await _connection.DisposeAsync();
  }
 
  public override void Abort() => Abort(new ConnectionAbortedException("The connection was aborted by the application via MultiplexedConnectionContext.Abort()."));
@@ -91,7 +91,7 @@ public override void Abort(ConnectionAbortedException abortReason)
  {
  try
  {
- var stream = await _connection.AcceptStreamAsync(cancellationToken);
+ var stream = await _connection.AcceptInboundStreamAsync(cancellationToken);
 
  QuicStreamContext? context = null;
 
@@ -122,11 +122,11 @@ public override void Abort(ConnectionAbortedException abortReason)
 
  return context;
  }
- catch (QuicConnectionAbortedException ex)
+ catch (QuicException ex) when (ex.QuicError == QuicError.ConnectionAborted)
  {
  // Shutdown initiated by peer, abortive.
- _error = ex.ErrorCode;
- QuicLog.ConnectionAborted(_log, this, ex.ErrorCode, ex);
+ _error = ex.ApplicationErrorCode;
+ QuicLog.ConnectionAborted(_log, this, ex.ApplicationErrorCode.GetValueOrDefault(), ex);
 
  ThreadPool.UnsafeQueueUserWorkItem(state =>
  {
@@ -138,7 +138,7 @@ public override void Abort(ConnectionAbortedException abortReason)
  // Throw error so consumer sees the connection is aborted by peer.
  throw new ConnectionResetException(ex.Message, ex);
  }
- catch (QuicOperationAbortedException ex)
+ catch (QuicException ex) when (ex.QuicError == QuicError.OperationAborted)
  {
  lock (_shutdownLock)
  {
@@ -194,16 +194,16 @@ public override async ValueTask<ConnectionContext> ConnectAsync(IFeatureCollecti
  {
  if (streamDirectionFeature.CanRead)
  {
- quicStream = await _connection.OpenBidirectionalStreamAsync(cancellationToken);
+ quicStream = await _connection.OpenOutboundStreamAsync(QuicStreamType.Bidirectional, cancellationToken);
  }
  else
  {
- quicStream = await _connection.OpenUnidirectionalStreamAsync(cancellationToken);
+ quicStream = await _connection.OpenOutboundStreamAsync(QuicStreamType.Unidirectional, cancellationToken);
  }
  }
  else
  {
- quicStream = await _connection.OpenBidirectionalStreamAsync(cancellationToken);
+ quicStream = await _connection.OpenOutboundStreamAsync(QuicStreamType.Bidirectional, cancellationToken);
  }
 
  // Only a handful of control streams are created by the server and they last for the

src/Servers/Kestrel/Transport.Quic/src/Internal/QuicConnectionListener.cs

@@ -28,21 +28,37 @@ public QuicConnectionListener(QuicTransportOptions options, ILogger log, EndPoin
  throw new NotSupportedException("QUIC is not supported or enabled on this platform. See https://aka.ms/aspnet/kestrel/http3reqs for details.");
  }
 
- _log = log;
- _context = new QuicTransportContext(_log, options);
- _quicListenerOptions = new();
-
  if (endpoint is not IPEndPoint listenEndPoint)
  {
  throw new InvalidOperationException($"QUIC doesn't support listening on the configured endpoint type. Expected {nameof(IPEndPoint)} but got {endpoint.GetType().Name}.");
  }
 
- _quicListenerOptions.ServerAuthenticationOptions = sslServerAuthenticationOptions;
- _quicListenerOptions.ListenEndPoint = listenEndPoint;
- _quicListenerOptions.IdleTimeout = options.IdleTimeout;
- _quicListenerOptions.MaxBidirectionalStreams = options.MaxBidirectionalStreamCount;
- _quicListenerOptions.MaxUnidirectionalStreams = options.MaxUnidirectionalStreamCount;
- _quicListenerOptions.ListenBacklog = options.Backlog;
+ if (sslServerAuthenticationOptions.ApplicationProtocols is null || sslServerAuthenticationOptions.ApplicationProtocols.Count == 0)
+ {
+ throw new InvalidOperationException("No application protocols specified.");
+ }
+
+ _log = log;
+ _context = new QuicTransportContext(_log, options);
+ _quicListenerOptions = new QuicListenerOptions
+ {
+ ApplicationProtocols = sslServerAuthenticationOptions.ApplicationProtocols,
+ ListenEndPoint = listenEndPoint,
+ ListenBacklog = options.Backlog,
+ ConnectionOptionsCallback = (connection, helloInfo, cancellationToken) =>
+ {
+ var connectionOptions = new QuicServerConnectionOptions
+ {
+ ServerAuthenticationOptions = sslServerAuthenticationOptions,
+ IdleTimeout = options.IdleTimeout,
+ MaxInboundBidirectionalStreams = options.MaxBidirectionalStreamCount,
+ MaxInboundUnidirectionalStreams = options.MaxUnidirectionalStreamCount,
+ DefaultCloseErrorCode = 0,
+ DefaultStreamErrorCode = 0,
+ };
+ return ValueTask.FromResult(connectionOptions);
+ }
+ };
 
  // Setting to listenEndPoint to prevent the property from being null.
  // This will be initialized when CreateListenerAsync() is invoked.
@@ -56,7 +72,7 @@ public async ValueTask CreateListenerAsync()
  _listener = await QuicListener.ListenAsync(_quicListenerOptions);
 
  // Listener endpoint will resolve an ephemeral port, e.g. 127.0.0.1:0, into the actual port.
- EndPoint = _listener.ListenEndPoint;
+ EndPoint = _listener.LocalEndPoint;
  }
 
  public async ValueTask<MultiplexedConnectionContext?> AcceptAsync(IFeatureCollection? features = null, CancellationToken cancellationToken = default)
@@ -75,7 +91,7 @@ public async ValueTask CreateListenerAsync()
 
  return connectionContext;
  }
- catch (QuicOperationAbortedException ex)
+ catch (QuicException ex) when (ex.QuicError == QuicError.OperationAborted)
  {
  _log.LogDebug("Listener has aborted with exception: {Message}", ex.Message);
  }
@@ -87,16 +103,17 @@ public async ValueTask UnbindAsync(CancellationToken cancellationToken = default
  await DisposeAsync();
  }
 
- public ValueTask DisposeAsync()
+ public async ValueTask DisposeAsync()
  {
  if (_disposed)
  {
- return ValueTask.CompletedTask;
+ return;
  }
 
- _listener?.Dispose();
+ if (_listener != null)
+ {
+ await _listener.DisposeAsync();
+ }
  _disposed = true;
-
- return ValueTask.CompletedTask;
  }
 }

src/Servers/Kestrel/Transport.Quic/src/Internal/QuicStreamContext.FeatureCollection.cs

@@ -1,6 +1,7 @@
 // Licensed to the .NET Foundation under one or more agreements.
 // The .NET Foundation licenses this file to you under the MIT license.
 
+using System.Net.Quic;
 using Microsoft.AspNetCore.Connections;
 using Microsoft.AspNetCore.Connections.Features;
 
@@ -41,7 +42,7 @@ public void AbortRead(long errorCode, ConnectionAbortedException abortReason)
  {
  _shutdownReadReason = abortReason;
  QuicLog.StreamAbortRead(_log, this, errorCode, abortReason.Message);
- _stream.AbortRead(errorCode);
+ _stream.Abort(QuicAbortDirection.Read, errorCode);
  }
  else
  {
@@ -61,7 +62,7 @@ public void AbortWrite(long errorCode, ConnectionAbortedException abortReason)
  {
  _shutdownWriteReason = abortReason;
  QuicLog.StreamAbortWrite(_log, this, errorCode, abortReason.Message);
- _stream.AbortWrite(errorCode);
+ _stream.Abort(QuicAbortDirection.Write, errorCode);
  }
  else
  {