Add native SCTP platform probe

Author: ammarheidari

README.md

@@ -45,6 +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 added using `SocketType.Seqpacket` and IP protocol number `132`; full production readiness still requires native transport completion and lab verification |
 
 ## Requirements
 
@@ -129,6 +130,7 @@ if (!M3uaTypedMessageParser.TryParseSignallingCongestion(
 - [Phase 6 Summary](docs/PHASE6_SUMMARY.md)
 - [Phase 7 Commercialization](docs/PHASE7_COMMERCIALIZATION.md)
 - [Phase 7 Summary](docs/PHASE7_SUMMARY.md)
+- [Phase 8 Native SCTP](docs/PHASE8_NATIVE_SCTP.md)
 - [Continuous Integration](docs/CI.md)
 - [SCTP Transport](docs/SCTP_TRANSPORT.md)
 - [Compatibility policy](docs/COMPATIBILITY.md)
@@ -149,6 +151,7 @@ The roadmap is intentionally conservative:
 5. Harden MAP SMS with external interoperability vectors and operator-profile validation.
 6. Use completed interoperability tooling to run external lab validation, native SCTP verification, and release automation hardening.
 7. Complete commercial readiness gates and publish governed release candidates.
+8. Complete Linux native SCTP transport and verification.
 
 ## License
 

docs/PHASE8_NATIVE_SCTP.md

@@ -0,0 +1,16 @@
+# Phase 8 Native SCTP
+
+Phase 8 implements the native SCTP production transport path, starting with Linux.
+
+## Platform Probe
+
+`NativeSctpPlatform.Probe()` checks whether the current runtime can create an SCTP socket.
+
+```csharp
+NativeSctpPlatformCapability capability = NativeSctpPlatform.Probe();
+bool canCreateSocket = capability.CanCreateSocket;
+```
+
+The SDK uses Linux `IPPROTO_SCTP` protocol number `132` with `SocketType.Seqpacket`. Windows and macOS remain contract-only until a verified production provider is selected.
+
+The probe is intentionally separate from readiness. Socket creation is necessary, but production readiness also requires metadata handling, lifecycle integration, integration tests, and external interoperability evidence.

docs/SCTP_TRANSPORT.md

@@ -118,3 +118,9 @@ The remaining production gate is explicit: native SCTP implementation and intero
 ## Phase 7 Native SCTP Matrix
 
 `SigtranNativeSctpSupport.GetSupportMatrix()` records native SCTP support claims for commercial release planning. Linux is marked as verification required, while Windows and macOS are contract-only until a production provider is selected and verified.
+
+## Phase 8 Native SCTP Probe
+
+`NativeSctpPlatform.Probe()` checks whether the current runtime can create a Linux SCTP socket using `SocketType.Seqpacket` and IP protocol number `132`.
+
+The probe does not mark the transport production-ready by itself. It is the first native SCTP implementation gate.

docs/SDK_ROADMAP.md

@@ -80,6 +80,15 @@ Status: SDK foundation is complete for trace formatting, conformance vector inve
 
 Status: SDK foundation is complete for commercial readiness gates, native SCTP support matrix, external interoperability evidence tracking, release candidate manifests, package governance, security policy, compatibility policy, observability profile, deployment profiles, and Phase 7 status reporting. Internal release readiness is available; commercial production readiness remains blocked until native SCTP verification, external interoperability evidence, package signing, and SBOM automation are complete.
 
+## Phase 8 - Native SCTP Production Transport
+
+- Probe Linux native SCTP socket creation using `SocketType.Seqpacket` and IP protocol number `132`.
+- Add native SCTP socket factory, connector, listener, send/receive path, lifecycle events, health snapshots, and reconnect integration.
+- Add Linux-focused integration test hooks that can run when SCTP kernel support is available.
+- Keep Windows and macOS contract-only until a verified provider is selected.
+
+Status: Phase 8 has started with a native SCTP platform probe. Production readiness remains blocked until the full native transport path and Linux interoperability verification are complete.
+
 ## Recommended First Deliverable
 
 The first useful SDK release should be an alpha package focused on M3UA over a transport abstraction:

src/sigtran.net.Tests/Program.cs

@@ -30,6 +30,7 @@
 Run("SIGTRAN observability profile exposes commercial signals", SigtranObservabilityProfileExposesCommercialSignals);
 Run("SIGTRAN deployment profiles expose commercial and development gates", SigtranDeploymentProfilesExposeCommercialAndDevelopmentGates);
 Run("SIGTRAN phase 7 status summarizes commercialization foundation", SigtranPhase7StatusSummarizesCommercializationFoundation);
+Run("Native SCTP platform probe reports socket creation capability", NativeSctpPlatformProbeReportsSocketCreationCapability);
 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);
@@ -390,6 +391,27 @@ static void SigtranPhase7StatusSummarizesCommercializationFoundation()
     Assert(SigtranPhase7Status.Describe().Contains("commercialReady=False", StringComparison.Ordinal), SigtranPhase7Status.Describe());
 }
 
+static void NativeSctpPlatformProbeReportsSocketCreationCapability()
+{
+    AssertEqual(132, NativeSctpPlatform.IpProtocolSctp, "native SCTP protocol number");
+    AssertEqual(SocketType.Seqpacket, NativeSctpPlatform.SctpSocketType, "native SCTP socket type");
+
+    NativeSctpPlatformCapability capability = NativeSctpPlatform.Probe();
+
+    if (OperatingSystem.IsLinux())
+    {
+        Assert(
+            capability.Status is NativeSctpPlatformStatus.SocketCreationSupported or NativeSctpPlatformStatus.SocketCreationUnavailable,
+            capability.Describe());
+    }
+    else
+    {
+        AssertEqual(NativeSctpPlatformStatus.UnsupportedOperatingSystem, capability.Status, "native SCTP unsupported OS status");
+    }
+
+    Assert(capability.Describe().Contains("nativeSctp", StringComparison.Ordinal), capability.Describe());
+}
+
 static void TcapBerElementEncodesShortAndLongLengths()
 {
     Span<byte> shortBuffer = stackalloc byte[8];

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

@@ -0,0 +1,96 @@
+using System.Net.Sockets;
+using System.Runtime.InteropServices;
+
+namespace sigtran.net.Layers.SCTP;
+
+/// <summary>
+/// Identifies native SCTP platform capability status.
+/// </summary>
+public enum NativeSctpPlatformStatus
+{
+    /// <summary>The operating system is not a supported native SCTP target.</summary>
+    UnsupportedOperatingSystem,
+
+    /// <summary>The operating system is supported, but socket creation failed.</summary>
+    SocketCreationUnavailable,
+
+    /// <summary>The operating system supports creating an SCTP socket.</summary>
+    SocketCreationSupported
+}
+
+/// <summary>
+/// Describes native SCTP platform capability.
+/// </summary>
+public sealed class NativeSctpPlatformCapability
+{
+    /// <summary>Creates a native SCTP platform capability result.</summary>
+    /// <param name="status">The capability status.</param>
+    /// <param name="reason">The diagnostic reason.</param>
+    public NativeSctpPlatformCapability(NativeSctpPlatformStatus status, string reason)
+    {
+        Status = status;
+        Reason = string.IsNullOrWhiteSpace(reason) ? throw new ArgumentException("Native SCTP capability reason is required.", nameof(reason)) : reason;
+    }
+
+    /// <summary>The capability status.</summary>
+    public NativeSctpPlatformStatus Status { get; }
+
+    /// <summary>The diagnostic reason.</summary>
+    public string Reason { get; }
+
+    /// <summary>Whether native SCTP socket creation is supported.</summary>
+    public bool CanCreateSocket => Status == NativeSctpPlatformStatus.SocketCreationSupported;
+
+    /// <summary>Formats a compact capability summary.</summary>
+    /// <returns>The capability summary.</returns>
+    public string Describe()
+    {
+        return $"nativeSctp status={Status} canCreateSocket={CanCreateSocket} reason={Reason}";
+    }
+}
+
+/// <summary>
+/// Provides native SCTP platform constants and capability probing.
+/// </summary>
+public static class NativeSctpPlatform
+{
+    /// <summary>The Linux IPPROTO_SCTP protocol number.</summary>
+    public const int IpProtocolSctp = 132;
+
+    /// <summary>The socket type used by SCTP one-to-one style associations.</summary>
+    public const SocketType SctpSocketType = SocketType.Seqpacket;
+
+    /// <summary>Gets the protocol type value used when creating native SCTP sockets.</summary>
+    public static ProtocolType SctpProtocolType => (ProtocolType)IpProtocolSctp;
+
+    /// <summary>Returns whether the current operating system is the supported native SCTP target.</summary>
+    /// <returns>True on Linux; otherwise false.</returns>
+    public static bool IsSupportedOperatingSystem()
+    {
+        return OperatingSystem.IsLinux();
+    }
+
+    /// <summary>Probes whether a native SCTP socket can be created.</summary>
+    /// <returns>The native SCTP platform capability.</returns>
+    public static NativeSctpPlatformCapability Probe()
+    {
+        if (!IsSupportedOperatingSystem())
+        {
+            return new(NativeSctpPlatformStatus.UnsupportedOperatingSystem, RuntimeInformation.OSDescription);
+        }
+
+        try
+        {
+            using Socket socket = new(AddressFamily.InterNetwork, SctpSocketType, SctpProtocolType);
+            return new(NativeSctpPlatformStatus.SocketCreationSupported, "SCTP socket creation succeeded.");
+        }
+        catch (SocketException ex)
+        {
+            return new(NativeSctpPlatformStatus.SocketCreationUnavailable, ex.SocketErrorCode.ToString());
+        }
+        catch (PlatformNotSupportedException ex)
+        {
+            return new(NativeSctpPlatformStatus.SocketCreationUnavailable, ex.Message);
+        }
+    }
+}