enricobuehler
a913042367
Ground-up low-latency streaming stack per docs/implementation-plan.md. M1 is
complete and tested; Linux host backends are cfg-gated stubs to be filled in on
real hardware (M0/M2).
lumen-core (built + tested on macOS/aarch64 — 21 tests):
- fec: ErasureCoder over GF(2^8) (reed-solomon-erasure, Moonlight-compatible)
and GF(2^16) Leopard-RS (reed-solomon-simd, the >1 Gbps wall-breaker); proptested
- packet: zero-copy #[repr(C)] framing, multi-block, FEC-aware reassembly
- crypto: AES-128-GCM with per-direction nonce salts + sequence-as-AAD
- session: host submit / client poll hot paths + input; loopback & UDP transports
- abi: opaque handles, versioned LumenConfig, panic guards; cbindgen-generated header
- acceptance: Rust loopback+proptest and a C harness that links the staticlib
Scaffold (compiles green on all platforms): lumen-host (vdisplay/capture/encode/
inject/web/pipeline seams under cfg(linux)), lumen-client-rs, tools/{loss-harness,
latency-probe}, Apple/Android client stubs, Gitea CI, docs.
Hardened against a multi-agent adversarial review (13 verified findings fixed,
regression-tested): reassembler memory-DoS bounds + block-consistency validation,
GCM nonce-reuse direction separation, ABI struct_size guard + range checks, FEC
shard-length guards, shard_payload datagram bound, key zeroization + Debug redaction.
Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
86 lines
3.0 KiB
Rust
86 lines
3.0 KiB
Rust
//! Runs the C ABI harness under `cargo test`: compiles `tests/c/harness.c`, links it
|
|
//! against the freshly built `liblumen_core.a`, and asserts it round-trips frames
|
|
//! through the lossy loopback. The cross-platform canonical path (querying rustc for
|
|
//! link flags) is `tests/c/run.sh`; this mirrors it so `cargo test` alone covers the
|
|
//! C boundary.
|
|
|
|
use std::path::{Path, PathBuf};
|
|
use std::process::Command;
|
|
|
|
/// Native libs the Rust staticlib needs, minus the ones `cc` already links by default
|
|
/// (`-lSystem`/`-lc`), to avoid duplicate-library linker warnings. See
|
|
/// `rustc --print native-static-libs`.
|
|
fn native_libs() -> &'static [&'static str] {
|
|
if cfg!(target_os = "macos") {
|
|
&["-liconv", "-lm"]
|
|
} else if cfg!(target_os = "linux") {
|
|
&["-lgcc_s", "-lutil", "-lrt", "-lpthread", "-lm", "-ldl"]
|
|
} else {
|
|
&[]
|
|
}
|
|
}
|
|
|
|
fn ensure_staticlib(profile_dir: &Path) -> PathBuf {
|
|
let staticlib = profile_dir.join("liblumen_core.a");
|
|
if !staticlib.exists() {
|
|
// `cargo test` doesn't always emit the standalone staticlib; build it. The
|
|
// outer cargo's build lock is released during test execution, so this is safe.
|
|
let cargo = std::env::var("CARGO").unwrap_or_else(|_| "cargo".into());
|
|
let _ = Command::new(cargo)
|
|
.args(["build", "-p", "lumen-core"])
|
|
.status();
|
|
}
|
|
staticlib
|
|
}
|
|
|
|
#[test]
|
|
fn c_abi_harness_round_trips() {
|
|
let manifest = PathBuf::from(env!("CARGO_MANIFEST_DIR")); // crates/lumen-core
|
|
let harness = manifest.join("tests/c/harness.c");
|
|
let include = manifest.join("../../include");
|
|
|
|
let exe = std::env::current_exe().expect("current_exe");
|
|
// .../target/<profile>/deps/c_abi-<hash> -> target/<profile>
|
|
let profile_dir = exe
|
|
.parent()
|
|
.and_then(Path::parent)
|
|
.expect("profile dir")
|
|
.to_path_buf();
|
|
|
|
let staticlib = ensure_staticlib(&profile_dir);
|
|
assert!(
|
|
staticlib.exists(),
|
|
"staticlib not found at {} (run `cargo build -p lumen-core`)",
|
|
staticlib.display()
|
|
);
|
|
assert!(
|
|
include.join("lumen_core.h").exists(),
|
|
"generated header missing; build lumen-core to regenerate it"
|
|
);
|
|
|
|
let cc = std::env::var("CC").unwrap_or_else(|_| "cc".into());
|
|
let out = profile_dir.join("lumen_c_harness");
|
|
|
|
let mut compile = Command::new(&cc);
|
|
compile
|
|
.args(["-std=c11", "-Wall", "-Wextra", "-O2", "-I"])
|
|
.arg(&include)
|
|
.arg(&harness)
|
|
.arg(&staticlib)
|
|
.args(native_libs())
|
|
.arg("-o")
|
|
.arg(&out);
|
|
|
|
match compile.status() {
|
|
Ok(s) => assert!(s.success(), "C harness failed to compile/link"),
|
|
Err(e) => {
|
|
// No C toolchain (unusual) — don't fail the whole suite; run.sh covers CI.
|
|
eprintln!("skipping C ABI test: cannot invoke `{cc}`: {e}");
|
|
return;
|
|
}
|
|
}
|
|
|
|
let run = Command::new(&out).status().expect("run C harness");
|
|
assert!(run.success(), "C harness reported a round-trip failure");
|
|
}
|