feat(webrtc): DataChannel support (SDP + ICE-lite + DTLS + SCTP over DTLS)

[gg582]

DataChannel-only WebRTC (v3.9 scope, #308): SDP offer/answer, ICE-lite, DTLS, SCTP. No media/RTP.

Commits

1. feat(webrtc) / test(webrtc) / fix(alloc) / fix(webrtc): the original stack.
2. docs(webrtc): Doxygen comments for src/net/webrtc/ (comments only).
3. feat(reactor): one-shot timers on the cwist reactor. This is new public API in reactor.h. The poll wait follows the earliest deadline and is still capped at 100 ms. cwist_reactor_stop() now writes the run flag atomically.
4. perf(webrtc): the WebRTC event loop now runs on that reactor, with the browser interop fixes below.

Design

• A ctx is one UDP socket served by one cwist reactor.
  • cwist_webrtc_ctx_new(port) creates its own reactor and thread.
  • cwist_webrtc_ctx_new_on(reactor, port) attaches to a reactor you already run.
• All ctx/conn state is touched only on the reactor thread. send, close, handle_offer and ctx_free post to it when called from another thread.
• Conns and ctxs are reference counted. A conn pointer is valid during a callback. To keep it longer, use cwist_webrtc_conn_retain()/release(). The new close handler tells you when a conn is gone.
• Nothing runs on a fixed tick:
  • Each conn has one timer: STUN retransmit, DTLS retransmit, handshake deadline, 30 s liveness, or 30 s expiry for an answered offer that never connects.
  • usrsctp's clock runs only while associations exist: every 10 ms after recent traffic, every 250 ms when quiet.
• I/O:
  • UDP is read with recvmmsg and written with sendmmsg.
  • DTLS runs on a datagram BIO.
  • Conns are looked up in a hash table.
  • Sends from other threads go through a lock-free per-conn inbox.
  • Sends are capped at 4 MiB queued per conn; see cwist_webrtc_conn_buffered_amount().

Bugs fixed along the way

• Wrong PPIDs. The code had DCEP 53, string 50, binary 51; RFC 8831 says 50/51/53. Our loopback test passed because both ends were ours. Against Chrome, the channel open was echoed back as text and binary messages were dropped. Empty messages (PPID 56/57) are now supported.
• Message callback API change. It now reports text vs binary (cwist_webrtc_data_type argument).
• STUN USERNAME read from the wrong side. It is recipient:sender. As a result the conn parked for an answered offer was never adopted and leaked.
• DTLS records could be split across UDP packets. The memory BIO was a byte stream read in 2 KiB slices.
• SCTP partial delivery. Messages delivered in pieces were passed up as separate messages; they are now reassembled using MSG_EOR.
• Data races. The pending queue and conn list were shared between threads without a lock. usrsctp's malloc'd buffers were freed with cwist_free. A static 1 MiB receive buffer was shared across ctxs. With several ctxs, the usrsctp clock ran fast.
• Example crashed its workers. It created the ctx before cwist_app_listen() forked, and every worker freed the parent's copy at shutdown and segfaulted. A ctx inherited across fork() is now detected, and the example creates one ctx per worker.

Testing

• make test passes, including test_webrtc and the new test_reactor_timer (io_uring and epoll).
• test_webrtc covers:
  • ping/pong, a 200 000-byte message both ways, typed and empty messages
  • the max-message-size and 4 MiB queue limits
  • close from another thread reaching the peer's close handler
  • parked-conn adoption
  • a ctx on a caller-run reactor
• test_webrtc is clean under ASan/UBSan/LSan and TSan (3 runs each). bench_webrtc under TSan is clean.
• Real browser: make test_webrtc_browser drives headless Chromium over CDP against example/webrtc. Results:
  • The channel opens in about 8 ms.
  • Text comes back as a string.
  • A 200 000-byte binary message comes back intact.
  • An empty string round-trips.
  • Average RTT is about 0.08 ms.
  • It needs chromium and Node 22+, so it is not part of make test. Firefox was not tested.
• make wasip2-smoke passes (WASI stubs for the timer API).

Numbers (loopback, ./bench_webrtc 200000 2000, 3 runs)

	before	after
idle ctx, context switches per second	101	11
64 B messages	195k msg/s	970k msg/s
1 KiB messages	26 MB/s	162 MB/s
64 KiB messages	37.6 MB/s	184 MB/s
RTT p50 / p99	25 / 40 µs	29 / 40–50 µs

The RTT p50 is about 4 µs worse. That is the reactor's one-shot re-arm plus the eventfd wake on each hop, and it is the same on io_uring and epoll.

Known limitations

• ICE-lite only: no STUN/TURN servers, no trickle ICE, IPv4 host candidates only.
• The peer certificate fingerprint is not yet checked against the SDP.
• Ordered, reliable channels only; channels cannot be closed individually (no stream reset).
• A ctx belongs to the process that created it. With cwist_app_listen() workers, create one per worker, as the example does.

[gg582]

Well, well...things are just mixed. This should be two pull request: one for adding comments, one for webrtc only. +10000 is weird.

[gg582]

KIMI SLOP