fix bugs

src/SuperSocket.Quic/QuicConnectionListener.cs

@@ -15,6 +15,7 @@ namespace SuperSocket.Quic
     internal sealed class QuicConnectionListener : IConnectionListener
     {
         private readonly ILogger _logger;
+        private readonly QuicTransportOptions _quicTransportOptions;
 
         private QuicListener _listenQuic;
         private CancellationTokenSource _cancellationTokenSource;
@@ -23,11 +24,14 @@ internal sealed class QuicConnectionListener : IConnectionListener
         public ListenOptions Options { get; }
         public bool IsRunning { get; private set; }
 
-        public QuicConnectionListener(ListenOptions options, IConnectionFactory connectionFactory, ILogger logger)
+        public QuicConnectionListener(ListenOptions options,
+            QuicTransportOptions quicTransportOptions,
+            IConnectionFactory connectionFactory, ILogger logger)
         {
             Options = options;
             ConnectionFactory = connectionFactory;
             _logger = logger;
+            _quicTransportOptions = quicTransportOptions;
         }
 
         public bool Start()
@@ -38,24 +42,27 @@ public bool Start()
             {
                 var listenEndpoint = options.ToEndPoint();
 
-                ArgumentNullException.ThrowIfNull(options.CertificateOptions);
+                if (options.CertificateOptions == null)
+                    throw new ArgumentNullException(nameof(options.CertificateOptions),"Quic requires an ssl certificate");
 
                 if (options.CertificateOptions.Certificate == null)
                     options.CertificateOptions.EnsureCertificate();
-                
+
                 var quicListenerOptions = new QuicListenerOptions
                 {
                     ListenBacklog = options.BackLog,
                     ListenEndPoint = listenEndpoint,
                     ApplicationProtocols = new List<SslApplicationProtocol> { SslApplicationProtocol.Http3 },
                     ConnectionOptionsCallback = (connection, ssl, token) => ValueTask.FromResult(
-                        new QuicServerConnectionOptions()
+                        new QuicServerConnectionOptions
                         {
-                            DefaultStreamErrorCode = 0,
-                            DefaultCloseErrorCode = 0,
-                            IdleTimeout = TimeSpan.FromMicroseconds(10),
-                            //MaxInboundBidirectionalStreams = 0,
-                            //MaxInboundUnidirectionalStreams = 0,
+                            DefaultStreamErrorCode = _quicTransportOptions.DefaultStreamErrorCode,
+                            DefaultCloseErrorCode = _quicTransportOptions.DefaultCloseErrorCode,
+                            IdleTimeout = _quicTransportOptions.IdleTimeout.HasValue
+                                ? TimeSpan.FromMicroseconds(_quicTransportOptions.IdleTimeout.Value)
+                                : Timeout.InfiniteTimeSpan,
+                            MaxInboundBidirectionalStreams = _quicTransportOptions.MaxBidirectionalStreamCount,
+                            MaxInboundUnidirectionalStreams = _quicTransportOptions.MaxUnidirectionalStreamCount,
                             ServerAuthenticationOptions = new SslServerAuthenticationOptions()
                             {
                                 ApplicationProtocols =
@@ -67,14 +74,7 @@ public bool Start()
                         })
                 };
 
-                var result = QuicListener.ListenAsync(quicListenerOptions);
-
-                if (result.IsCompleted)
-                    _listenQuic = result.Result;
-                else
-                    _listenQuic = result.GetAwaiter().GetResult();
-
-                var listenSocket = _listenQuic;
+                var listenSocket = QuicListener.ListenAsync(quicListenerOptions).GetAwaiter().GetResult();
 
                 IsRunning = true;
 
@@ -92,7 +92,6 @@ public bool Start()
 
 
         private async Task KeepAcceptAsync(QuicListener listenSocket, CancellationToken cancellationToken)
-
         {
             while (!cancellationToken.IsCancellationRequested)
             {
@@ -156,4 +155,4 @@ public override string ToString()
             return Options?.ToString();
         }
     }
-}
+}

src/SuperSocket.Quic/QuicConnectionListenerFactory.cs

@@ -1,4 +1,5 @@
 using Microsoft.Extensions.Logging;
+using Microsoft.Extensions.Options;
 using SuperSocket.Connection;
 using SuperSocket.Server.Abstractions;
 using SuperSocket.Server.Abstractions.Connections;
@@ -7,21 +8,26 @@ namespace SuperSocket.Quic
 {
     internal class QuicConnectionListenerFactory : IConnectionListenerFactory
     {
+        private readonly QuicTransportOptions _quicTransportOptions;
         private readonly IConnectionFactoryBuilder _connectionFactoryBuilder;
 
-        public QuicConnectionListenerFactory(IConnectionFactoryBuilder connectionFactoryBuilder)
+        public QuicConnectionListenerFactory(IConnectionFactoryBuilder connectionFactoryBuilder,
+            IOptions<QuicTransportOptions> options)
         {
             _connectionFactoryBuilder = connectionFactoryBuilder;
+            _quicTransportOptions = options.Value;
         }
-
-        public IConnectionListener CreateConnectionListener(ListenOptions options, ConnectionOptions connectionOptions, ILoggerFactory loggerFactory)
+
+        public IConnectionListener CreateConnectionListener(ListenOptions options, ConnectionOptions connectionOptions,
+            ILoggerFactory loggerFactory)
         {
             connectionOptions.Logger = loggerFactory.CreateLogger(nameof(IConnection));
             var connectionFactoryLogger = loggerFactory.CreateLogger(nameof(QuicConnectionListener));
 
             var connectionFactory = _connectionFactoryBuilder.Build(options, connectionOptions);
 
-            return new QuicConnectionListener(options,  connectionFactory, connectionFactoryLogger);
+            return new QuicConnectionListener(options, _quicTransportOptions, connectionFactory,
+                connectionFactoryLogger);
         }
     }
 }

src/SuperSocket.Quic/QuicServerHostBuilderExtensions.cs

@@ -4,27 +4,38 @@
 using SuperSocket.Server.Abstractions.Connections;
 using SuperSocket.Server.Abstractions.Host;
 using SuperSocket.Quic;
+
 #pragma warning disable CA2252
 
 namespace SuperSocket.Server
 {
     public static class QuicServerHostBuilderExtensions
     {
         public static ISuperSocketHostBuilder UseQuic(this ISuperSocketHostBuilder hostBuilder)
+        {
+            return (hostBuilder as ISuperSocketHostBuilder).UseQuic(o => { }) as
+                ISuperSocketHostBuilder;
+        }
+
+        public static ISuperSocketHostBuilder UseQuic(this ISuperSocketHostBuilder hostBuilder,
+            Action<QuicTransportOptions> globalConfigure)
         {
             if (!QuicListener.IsSupported)
                 throw new PlatformNotSupportedException("System.Net.Quic is not supported on this platform.");
-            
+
             return hostBuilder.ConfigureServices((_, services) =>
             {
+                services.Configure(globalConfigure);
                 services.AddSingleton<IConnectionListenerFactory, QuicConnectionListenerFactory>();
                 services.AddSingleton<IConnectionFactoryBuilder, QuicConnectionFactoryBuilder>();
             }) as ISuperSocketHostBuilder;
         }
 
-        public static ISuperSocketHostBuilder<TReceivePackage> UseQuic<TReceivePackage>(this ISuperSocketHostBuilder<TReceivePackage> hostBuilder)
+        public static ISuperSocketHostBuilder<TReceivePackage> UseQuic<TReceivePackage>(
+            this ISuperSocketHostBuilder<TReceivePackage> hostBuilder)
         {
-            return (hostBuilder as ISuperSocketHostBuilder).UseQuic() as ISuperSocketHostBuilder<TReceivePackage>;
+            return (hostBuilder as ISuperSocketHostBuilder).UseQuic(o => { }) as
+                ISuperSocketHostBuilder<TReceivePackage>;
         }
     }
-}
+}

src/SuperSocket.Quic/QuicTransportOptions.cs

@@ -8,21 +8,20 @@ public sealed class QuicTransportOptions
     /// The maximum number of concurrent inbound uni-directional streams per connection.
     /// </summary>
     public int MaxUnidirectionalStreamCount { get; set; } = 10;
-
-    /// <summary>The maximum read size.</summary>
-    public long MaxReadBufferSize { get; set; } = 1048576L;
-
-    /// <summary>The maximum write size.</summary>
-    public long MaxWriteBufferSize { get; set; } = 65536L;
-
-    /// <summary>The maximum length of the pending connection queue.</summary>
-    public int Backlog { get; set; } = 512;
-
+
     /// <summary>
     /// Error code used when the stream needs to abort the read or write side of the stream internally.
     /// </summary>
     public long DefaultStreamErrorCode { get; set; }
 
-    /// <summary>Error code used when an open connection is disposed.</summary>
+    /// <summary>
+    /// Error code used when an open connection is disposed
+    /// </summary>
     public long DefaultCloseErrorCode { get; set; }
+
+    /// <summary>Gets or sets the idle timeout for connections. The idle timeout is the time after which the connection will be closed.
+    /// Default <see cref="F:System.TimeSpan.Zero" /> means underlying implementation default idle timeout.</summary>
+    /// <returns>The idle timeout for connections. The default is <see cref="F:System.TimeSpan.Zero" />, which means that the default idle timeout of the underlying implementation is used.</returns>
+    public int? IdleTimeout { get; set; } 
+
 }

test/SuperSocket.Tests/QuicHostConfigurator.cs

@@ -21,10 +21,10 @@
 using SuperSocket.Quic;
 using SuperSocket.Quic.Connection;
 
+#pragma warning disable CA2252
+#if NET7_0_OR_GREATER
 namespace SuperSocket.Tests
 {
-#if NET7_0_OR_GREATER
-
     public class QuicHostConfigurator : IHostConfigurator
     {
         private static readonly ArrayPool<byte> _bufferPool = ArrayPool<byte>.Shared;
@@ -100,7 +100,6 @@ public QuicClient(IPipelineFilter<TReceivePackage> pipelineFilter, ConnectionOpt
             protected override async ValueTask<bool> ConnectAsync(EndPoint remoteEndPoint,
                 CancellationToken cancellationToken)
             {
-#pragma warning disable CA2252
                 var quicConnection = await QuicConnection.ConnectAsync(
                     cancellationToken: cancellationToken,
                     options: new QuicClientConnectionOptions
@@ -147,6 +146,5 @@ public Socket CreateClient()
             throw new NotImplementedException();
         }
     }
-
-#endif
-}
+}
+#endif