C++20 · SIP/SDP · RTP · Real-Time Telemetry
ATC Voice Resilience Lab: Core Networking Prototype
A C++20 mission-critical voice networking lab for SIP/SDP call control, real RTP media resilience, deterministic fault injection, and live operational telemetry.
A complete C++20 networking prototype that simulates an air-traffic controller voice path between a controller endpoint and a radio gateway. The system establishes bounded SIP/SDP sessions, transports real bidirectional synthetic G.711 PCMU media through an asynchronous RTP relay, injects deterministic failures, measures media quality, streams structured telemetry, and visualizes the full lifecycle in a secure real-time dashboard.
- ROLE
- Software Architect, C++20 Networking Engineer and Full-Stack Developer
- YEAR
- 2026
TECH_STACK
Technologies
MEDIA
Project media
CONTEXT
Technical context
Voice communication in air-traffic environments depends on predictable signaling, continuous media transport, rapid fault detection, clear operational state, and reproducible engineering evidence. Building a full certified ATC system was intentionally out of scope, so the project focuses on a bounded but functional vertical slice that demonstrates the most relevant networking, C++20, testing, security, observability, and delivery skills in a locally reproducible laboratory environment.
PROBLEM
Problem
A simple static simulator would not demonstrate how signaling, media transport, asynchronous networking, fault injection, recovery, telemetry, security, and delivery interact in a mission-critical communication path. The challenge was to build a compact system that transports real RTP packets, exposes meaningful failure modes, remains deterministic enough for automated validation, presents its state clearly to an operator, and can be built, tested, packaged, and defended professionally.
OVERVIEW
Project overview
The system models an air-traffic voice communication path between a simulated controller endpoint and a simulated radio gateway. SIP and SDP establish and describe the session while RTP transports real synthetic G.711 PCMU media through an asynchronous C++ relay.
The media layer validates packet structure and sequence behavior, forwards bidirectional streams, measures quality indicators, and applies deterministic impairment profiles. Scenarios cover normal operation, partial packet loss, signaling correlation failure, and a timed full media interruption followed by recovery and stabilization.
A local Boost.Beast gateway publishes health, scenario control, snapshots, and structured WebSocket telemetry. The browser dashboard converts those events into live counters, semantic component states, signaling and media timelines, a professional telemetry table, resizable log panels, follow-latest behavior, and downloadable sanitized logs.
The security model intentionally limits exposure to a local laboratory environment. It binds only to loopback, validates Host and Origin, enforces request and WebSocket limits, applies throttling and security headers, rejects unsafe traffic, and returns structured overload responses without pretending to provide production ATC security.
Engineering quality is demonstrated through 171 unique unit and integration tests, compiler matrices, static analysis, sanitizers, coverage, deterministic scenario fixtures, real browser validation, performance benchmarks, Docker delivery, Jenkins-compatible stages, locked dependencies, install rules, checksums, and reproducible archives.
The project remains intentionally bounded: it does not claim ED-137 compliance, certification, operational ATC deployment, SRTP, TLS, authentication, RTCP, radio hardware integration, or redundant physical infrastructure. Its purpose is to demonstrate mission-critical networking engineering practices in a transparent and defensible prototype.
APPROACH
Technical approach
- Established a reproducible C++20 project skeleton with CMake presets, GCC, Clang, Conan, Ninja and GoogleTest
- Implemented RTP packet parsing, serialization, G.711 PCMU helpers and deterministic synthetic media generation
- Built asynchronous UDP transport and bidirectional RTP relay processing with Boost.Asio
- Implemented a bounded SIP message subset, SDP negotiation data and a call-session state machine
- Created simulated controller and radio-gateway endpoints connected through a SIP back-to-back user agent flow
- Added deterministic Baseline, Packet Loss and Call-ID Mismatch scenarios
- Created a 30-second live resilience sequence with healthy, outage, recovery, stabilized and completed phases
- Measured validated, forwarded, dropped, duplicated, reordered and jitter-related RTP behavior
- Defined structured telemetry contracts and streamed events through a local HTTP and WebSocket gateway
- Built a responsive operational dashboard for signaling, media flow, counters, timelines and event telemetry
- Added run-generation isolation so every scenario starts from a complete clean event stream and rejects stale callbacks
- Separated endpoint availability, signaling state, RTP path state, relay forwarding state, current health and final outcome
- Added independently resizable SIP/SDP and telemetry panels with viewport-edge drag auto-scroll
- Added sanitized per-run SIP/SDP and telemetry log export
- Hardened the local gateway with loopback binding, Host and Origin validation, bounded parsers, client limits, throttling, CSP and structured overload responses
- Added unit, integration, stress, dashboard, security, delivery and benchmark validation while keeping 171 unique registered CTests
- Validated GCC and Clang Debug and Release configurations, Clang-Tidy, sanitizers and code coverage
- Added six deterministic Release benchmark cases for packet, media, relay, telemetry and virtual end-to-end processing
- Created a multi-stage Docker build, test and package workflow with Jenkins pipeline structure and a locked dependency graph
- Produced deterministic install layouts, reproducible release archives, delivery smoke tests and a versioned 1.0.1 patch release
FOCUS
Technical focus
- Asynchronous network programming and event-driven architecture
- SIP and SDP message handling with bounded protocol subsets
- RTP packet processing and bidirectional UDP media transport
- G.711 PCMU synthetic voice generation
- Deterministic packet-loss and outage fault injection
- Media-quality metrics and resilience-state modeling
- HTTP and WebSocket telemetry streaming
- Real-time operational dashboard design
- Run isolation and stale asynchronous callback rejection
- Security hardening for local network services
- Automated unit, integration, stress and browser testing
- Static analysis, sanitizers and coverage engineering
- Deterministic performance benchmarking
- Containerized build, test and release packaging
- Reproducible software delivery and documentation
ARCHITECTURE
Architecture notes
- Simulated Controller Endpoint initiates a bounded SIP/SDP call flow
- SIP back-to-back user agent logic coordinates controller and radio-gateway sessions
- Simulated Radio Gateway accepts signaling and participates in bidirectional media exchange
- Synthetic G.711 PCMU producers generate deterministic 20 ms RTP frames
- Asynchronous UDP transport carries real RTP packets over IPv4 loopback
- Bidirectional RTP relay validates, forwards, drops and measures packets
- Scenario runner applies deterministic healthy, packet-loss, mismatch and timed-outage behavior
- Virtual scheduling supports fast deterministic tests while the live demo uses paced real-time execution
- Structured telemetry events provide a stable contract between the C++ core and browser
- Boost.Beast HTTP and WebSocket gateway exposes control, health, snapshots and event streams
- Run-generation state prevents old callbacks or streams from contaminating a new scenario
- Semantic flow derivation separates component, signaling, media-path, relay, health and outcome states
- Static dashboard assets are tracked by an explicit CMake dependency target and copied with copy_if_different
- Loopback-only binding and layered request validation define the local security boundary
- CMake install rules produce bin, share, config and documentation layouts
- Docker multi-stage toolchain, build, test and package images create an isolated delivery path
- Deterministic tar packaging normalizes ordering, ownership, permissions and timestamps
HIGHLIGHTS
Engineering highlights
- Complete bounded SIP/SDP call lifecycle between controller and radio-gateway simulators
- Real bidirectional G.711 PCMU RTP media transported through a C++ relay
- Live 30-second resilience demonstration with healthy, outage, recovery and stabilization phases
- Exact final resilience counters of 1500 validated, 1250 forwarded and 250 dropped packets per direction
- Current health returns to Healthy while final run outcome remains Recovered
- Baseline, Packet Loss and Call-ID Mismatch scenarios with layer-accurate system states
- 318 structured events in the complete timed resilience stream
- Professional real-time dashboard with four scenario controls and no static mock data
- Run-local signaling and telemetry streams beginning from event number one on every execution
- Independent resizable SIP/SDP and telemetry panels with edge-triggered page auto-scroll
- Sanitized downloadable SIP/SDP and telemetry logs for each completed run
- Full-width monitoring-style telemetry table with aligned compact and flexible columns
- Loopback-only security with Host, Origin, parser, WebSocket, client and throttle controls
- Structured HTTP 503 overload handling with a bounded lightweight responder pool
- 171 unique automated CTests
- GCC and Clang Debug and Release validation
- Clean Clang-Tidy and sanitizer execution
- 86.0% line coverage and 72.0% branch coverage
- Six deterministic Release benchmark workloads
- Docker and Jenkins-compatible build, test and packaging pipeline
- Conan 2 lockfile and reproducible version 1.0.1 release package
OUTCOME
Outcome
The final version 1.0.1 release delivers a functional and reproducible C++20 networking system rather than a static mock-up. It establishes bounded SIP/SDP sessions, transports real synthetic PCMU media in both directions, injects and observes failures, recovers deterministically, streams 318-event resilience telemetry, and presents the full system state through a polished browser dashboard. The live resilience demonstration validates 1,500 RTP frames per direction, forwards 1,250, drops 250 during the injected outage, reports 16.66% cumulative loss, returns current loss to zero, restores current health to Healthy, and preserves the run outcome as Recovered. The project finishes with 171 unique tests, complete GCC and Clang matrices, clean static analysis and sanitizers, 86.0% line coverage, 72.0% branch coverage, six performance benchmarks, loopback security controls, Docker delivery, and byte-reproducible packaging.