Add native SCTP listener

Author: ammarheidari

README.md

@@ -45,7 +45,7 @@ The first production milestone is M3UA over a transport abstraction. SCCP, TCAP,
 | Observability | Phase 7 profile added for commercial metrics, trace categories, and health signals |
 | Deployment profiles | Phase 7 profiles added for commercial Linux and local development use |
 | Phase 7 status | Commercialization foundation complete; commercial production remains blocked on native SCTP verification, external lab evidence, signing, and SBOM |
-| Native SCTP implementation | Phase 8 started: Linux SCTP socket probe, socket factory, endpoint connection planner, native socket adapter, and client connector added; full production readiness still requires native transport completion and lab verification |
+| Native SCTP implementation | Phase 8 started: Linux SCTP socket probe, socket factory, endpoint connection planner, native socket adapter, client connector, and server listener added; full production readiness still requires native transport completion and lab verification |
 
 ## Requirements
 

docs/PHASE8_NATIVE_SCTP.md

@@ -58,3 +58,16 @@ NativeSctpSocketAdapter socket = await connector.ConnectAsync(options);
 ```
 
 The connector is Linux-native only through `NativeSctpSocketFactory`; unsupported platforms fail before attempting network I/O.
+
+## Listener
+
+`NativeSctpListener` provides the server-side bind/listen/accept path for native SCTP.
+
+```csharp
+NativeSctpListenerOptions options = new(new SctpEndpoint("0.0.0.0", 2905));
+using NativeSctpListener listener = new();
+await listener.StartAsync(options);
+NativeSctpSocketAdapter association = await listener.AcceptAsync(options);
+```
+
+The listener shares the same socket factory and unsupported-platform behavior as the connector. Real accept/send/receive verification belongs in Linux SCTP lab runs.

docs/SCTP_TRANSPORT.md

@@ -132,3 +132,5 @@ The probe does not mark the transport production-ready by itself. It is the firs
 `NativeSctpSocketAdapter` wraps an SCTP socket as `ISctpSocket` and reports `SctpTransportHealth` snapshots for native associations.
 
 `NativeSctpConnector` performs the client-side bind/connect path and returns an established native adapter.
+
+`NativeSctpListener` provides the server-side bind/listen/accept path for Linux native SCTP lab scenarios.

src/sigtran.net.Tests/Program.cs

@@ -35,6 +35,7 @@
 Run("Native SCTP connection planner resolves endpoints", NativeSctpConnectionPlannerResolvesEndpoints);
 Run("Native SCTP socket adapter reports lifecycle health", NativeSctpSocketAdapterReportsLifecycleHealth);
 Run("Native SCTP connector reports unsupported platform safely", NativeSctpConnectorReportsUnsupportedPlatformSafely);
+Run("Native SCTP listener validates options and unsupported platform", NativeSctpListenerValidatesOptionsAndUnsupportedPlatform);
 Run("TCAP BER element encodes short and long lengths", TcapBerElementEncodesShortAndLongLengths);
 Run("TCAP transaction identifiers use BER context tags", TcapTransactionIdentifiersUseBerContextTags);
 Run("TCAP BER Invoke component round-trips", TcapBerInvokeComponentRoundTrips);
@@ -492,6 +493,24 @@ static void NativeSctpConnectorReportsUnsupportedPlatformSafely()
     }
 }
 
+static void NativeSctpListenerValidatesOptionsAndUnsupportedPlatform()
+{
+    AssertThrows<ArgumentOutOfRangeException>(() => new NativeSctpListenerOptions(new SctpEndpoint("127.0.0.1", 2905), backlog: 0));
+    AssertThrows<ArgumentOutOfRangeException>(() => new NativeSctpListenerOptions(new SctpEndpoint("127.0.0.1", 2905), outboundStreams: 0));
+
+    NativeSctpListenerOptions options = new(new SctpEndpoint("127.0.0.1", 2905), backlog: 1);
+    AssertEqual((uint)SctpPayloadProtocolIdentifiers.M3ua, options.DefaultPayloadProtocolIdentifier, "native listener default PPID");
+
+    NativeSctpPlatformCapability capability = NativeSctpPlatform.Probe();
+    if (!capability.CanCreateSocket)
+    {
+        using NativeSctpListener listener = new();
+        NativeSctpUnavailableException exception = AssertThrows<NativeSctpUnavailableException>(() =>
+            listener.StartAsync(options).GetAwaiter().GetResult());
+        AssertEqual(capability.Status, exception.Capability.Status, "native listener unsupported status");
+    }
+}
+
 static void TcapBerElementEncodesShortAndLongLengths()
 {
     Span<byte> shortBuffer = stackalloc byte[8];

src/sigtran.net/Layers/SCTP/NativeSctpListener.cs

@@ -0,0 +1,141 @@
+using System.Net;
+using System.Net.Sockets;
+
+namespace sigtran.net.Layers.SCTP;
+
+/// <summary>
+/// Options for a native SCTP listener.
+/// </summary>
+public sealed class NativeSctpListenerOptions
+{
+    /// <summary>Creates native SCTP listener options.</summary>
+    /// <param name="localEndpoint">The local endpoint to bind.</param>
+    /// <param name="backlog">The listen backlog.</param>
+    /// <param name="outboundStreams">The outbound stream count to report for accepted associations.</param>
+    /// <param name="inboundStreams">The inbound stream count to report for accepted associations.</param>
+    /// <param name="defaultPayloadProtocolIdentifier">The default Payload Protocol Identifier.</param>
+    public NativeSctpListenerOptions(
+        SctpEndpoint localEndpoint,
+        int backlog = 100,
+        ushort outboundStreams = 1,
+        ushort inboundStreams = 1,
+        uint defaultPayloadProtocolIdentifier = SctpPayloadProtocolIdentifiers.M3ua)
+    {
+        if (backlog <= 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(backlog), "Listen backlog must be positive.");
+        }
+
+        if (outboundStreams == 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(outboundStreams), "Outbound stream count must be positive.");
+        }
+
+        if (inboundStreams == 0)
+        {
+            throw new ArgumentOutOfRangeException(nameof(inboundStreams), "Inbound stream count must be positive.");
+        }
+
+        LocalEndpoint = localEndpoint ?? throw new ArgumentNullException(nameof(localEndpoint));
+        Backlog = backlog;
+        OutboundStreams = outboundStreams;
+        InboundStreams = inboundStreams;
+        DefaultPayloadProtocolIdentifier = defaultPayloadProtocolIdentifier;
+    }
+
+    /// <summary>The local endpoint to bind.</summary>
+    public SctpEndpoint LocalEndpoint { get; }
+
+    /// <summary>The listen backlog.</summary>
+    public int Backlog { get; }
+
+    /// <summary>The outbound stream count to report for accepted associations.</summary>
+    public ushort OutboundStreams { get; }
+
+    /// <summary>The inbound stream count to report for accepted associations.</summary>
+    public ushort InboundStreams { get; }
+
+    /// <summary>The default Payload Protocol Identifier.</summary>
+    public uint DefaultPayloadProtocolIdentifier { get; }
+}
+
+/// <summary>
+/// Native SCTP server-side listener.
+/// </summary>
+public sealed class NativeSctpListener : IDisposable
+{
+    private readonly INativeSctpSocketFactory _socketFactory;
+    private readonly NativeSctpEndpointResolver _resolver = new();
+    private Socket? _listenSocket;
+
+    /// <summary>Creates a native SCTP listener.</summary>
+    /// <param name="socketFactory">The socket factory.</param>
+    public NativeSctpListener(INativeSctpSocketFactory? socketFactory = null)
+    {
+        _socketFactory = socketFactory ?? new NativeSctpSocketFactory();
+    }
+
+    /// <summary>Starts listening on the configured local endpoint.</summary>
+    /// <param name="options">The listener options.</param>
+    /// <param name="ct">A cancellation token.</param>
+    public async Task StartAsync(NativeSctpListenerOptions options, CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+        if (_listenSocket is not null)
+        {
+            throw new InvalidOperationException("Native SCTP listener has already started.");
+        }
+
+        IPEndPoint local = await _resolver.ResolveAsync(options.LocalEndpoint, ct).ConfigureAwait(false);
+        Socket socket = _socketFactory.CreateSocket();
+        try
+        {
+            socket.Bind(local);
+            socket.Listen(options.Backlog);
+            _listenSocket = socket;
+        }
+        catch
+        {
+            socket.Dispose();
+            throw;
+        }
+    }
+
+    /// <summary>Accepts one native SCTP association.</summary>
+    /// <param name="options">The listener options used to describe accepted association defaults.</param>
+    /// <param name="ct">A cancellation token.</param>
+    /// <returns>The accepted native SCTP socket adapter.</returns>
+    public async Task<NativeSctpSocketAdapter> AcceptAsync(NativeSctpListenerOptions options, CancellationToken ct = default)
+    {
+        ArgumentNullException.ThrowIfNull(options);
+        Socket listenSocket = _listenSocket ?? throw new InvalidOperationException("Native SCTP listener has not started.");
+        Socket accepted = await listenSocket.AcceptAsync(ct).ConfigureAwait(false);
+
+        SctpEndpoint remote = ToSctpEndpoint(accepted.RemoteEndPoint, "remote");
+        SctpConnectionOptions connectionOptions = new(
+            remote,
+            options.LocalEndpoint,
+            options.OutboundStreams,
+            options.InboundStreams,
+            options.DefaultPayloadProtocolIdentifier);
+
+        return new NativeSctpSocketAdapter(accepted, connectionOptions, SctpAssociationState.Established);
+    }
+
+    /// <inheritdoc />
+    public void Dispose()
+    {
+        _listenSocket?.Dispose();
+        _listenSocket = null;
+    }
+
+    private static SctpEndpoint ToSctpEndpoint(EndPoint? endpoint, string label)
+    {
+        if (endpoint is IPEndPoint ip)
+        {
+            return new SctpEndpoint(ip.Address.ToString(), ip.Port);
+        }
+
+        throw new InvalidOperationException($"Accepted SCTP socket did not expose a valid {label} endpoint.");
+    }
+}