Quic listener disposal throws QuicException

[pepone]

I'm getting a QuicException when calling DisposeAsync on the Quic listener, throwing exceptions from DisposeAsync seems quite unusual, is this exception expected?

System.Net.Quic.QuicException: Operation aborted.
   at System.Net.Quic.QuicListener.DisposeAsync()
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](TStateMachine& stateMachine)
   at System.Net.Quic.QuicListener.DisposeAsync()

Tagging subscribers to this area: @dotnet/ncl
See info in area-owners.md if you want to be subscribed.

Issue Details

---

I'm getting a QuicException when calling DisposeAsync on the Quic listener, throwing exceptions from DisposeAsync seems quite unusual, is this exception expected?

System.Net.Quic.QuicException: Operation aborted.
   at System.Net.Quic.QuicListener.DisposeAsync()
   at System.Runtime.CompilerServices.AsyncMethodBuilderCore.Start[TStateMachine](TStateMachine& stateMachine)
   at System.Net.Quic.QuicListener.DisposeAsync()

Author:	pepone
Assignees:	-
Labels:	area-System.Net.Quic
Milestone:	-

[ManickaP]

No, not expected at all. Could you share the code that causes this? Does it reproduce somewhat regularly?

[pepone]

I was somehow confused by this Stack in my tests, DisposeAsync is not throwing, but an unobserved task exception originates there. I was able to reproduce with this code

using System.Net;
using System.Net.Security;
using System.Net.Quic;
using System.Runtime.CompilerServices;
using System.Runtime.Versioning;
using System.Security.Authentication;
using System.Security.Cryptography.X509Certificates;
using System.Diagnostics;


[assembly: SupportedOSPlatform("linux")]
[assembly: SupportedOSPlatform("macOS")]
[assembly: SupportedOSPlatform("windows")]

var clientAuthenticationOptions = new SslClientAuthenticationOptions
{
    RemoteCertificateValidationCallback = (sender, certificate, chain, errors) => true,
    ApplicationProtocols = new List<SslApplicationProtocol>
    {
        new SslApplicationProtocol("foo")
    }
};

TaskScheduler.UnobservedTaskException += (object? sender, UnobservedTaskExceptionEventArgs e) =>
    Console.WriteLine($"UTE: {sender}, {e.Exception}");

await using QuicListener listener = await QuicListener.ListenAsync(
    new QuicListenerOptions
    {
        ListenEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 0),
        ConnectionOptionsCallback = GetConnectionOptionsAsync,
        ApplicationProtocols = new List<SslApplicationProtocol>
        {
            new SslApplicationProtocol("foo")
        }
    },
    CancellationToken.None);

var connectTask = ConnectAsync();
await listener.DisposeAsync();
await connectTask;

GC.Collect();
GC.WaitForPendingFinalizers();

async Task ConnectAsync()
{
    var connections = new List<QuicConnection>();
    while (true)
    {
        try
        {
            var connection = await QuicConnection.ConnectAsync(
                new QuicClientConnectionOptions
                {
                    ClientAuthenticationOptions = clientAuthenticationOptions,
                    DefaultStreamErrorCode = 1,
                    DefaultCloseErrorCode = 1,
                    RemoteEndPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), listener.LocalEndPoint.Port),
                },
                default);
            connections.Add(connection);
        }
        catch
        {
            break;
        }
    }
    await Task.WhenAll(connections.Select(connection => connection.DisposeAsync().AsTask()));
}

ValueTask<QuicServerConnectionOptions> GetConnectionOptionsAsync(
    QuicConnection connection,
    SslClientHelloInfo sslInfo,
    CancellationToken cancellationToken) =>
    new(new QuicServerConnectionOptions
    {
        ServerAuthenticationOptions = new SslServerAuthenticationOptions()
        {
            ServerCertificate = new X509Certificate2("certs/server.p12", "password"),
            ApplicationProtocols = new List<SslApplicationProtocol> // Mandatory with Quic
            {
                new SslApplicationProtocol("foo")
            }
        },
        DefaultStreamErrorCode = 1,
        DefaultCloseErrorCode = 1,
    });

Output

UTE: System.Threading.Tasks.Task, System.AggregateException: A Task's exception(s) were not observed either by Waiting on the Task or accessing its Exception property. As a result, the unobserved exception was rethrown by the finalizer thread. (Operation aborted.)
 ---> System.Net.Quic.QuicException: Operation aborted.
   at System.Net.Quic.QuicConnection.HandleEventShutdownComplete(_SHUTDOWN_COMPLETE_e__Struct& data)
   at System.Net.Quic.QuicConnection.HandleConnectionEvent(QUIC_CONNECTION_EVENT& connectionEvent)
   at System.Net.Quic.QuicConnection.NativeCallback(QUIC_HANDLE* connection, Void* context, QUIC_CONNECTION_EVENT* connectionEvent)
--- End of stack trace from previous location ---

   --- End of inner exception stack trace ---

[ManickaP]

Thanks for the repro and bug report! This is potentially dupe of #80111. We will certainly look into it.

[pepone]

Good

if you add a loop around the test case, you get a few different UTEs, including one similar to the one I originally reported.

[ManickaP]

Perfect, easier to repro the original bug for us!

[wfurt]

I cannot reproduce it with 8.0 preview 2. Could you give it try @pepone?
(and I can reproduce it with 7.0)

This issue has been marked needs-author-action and may be missing some important information.