Skip to main content

qualia_core_db/net/qdnf/harness/
two_process.rs

1//! E05.2 — two OS-process IPC evidence. Never PhysicalNetwork / two-host.
2
3use core::sync::atomic::{AtomicBool, Ordering};
4
5use crate::net::qdnf::errors::QdnfError;
6use crate::net::qdnf::harness::qualification::{
7    EvidenceClass, Instrument, InstrumentResult, InstrumentVerdict,
8};
9
10const CHILD_ENV: &str = "QDNF_TWO_PROCESS_CHILD";
11#[cfg(unix)]
12const SOCK_ENV: &str = "QDNF_TWO_PROCESS_SOCK";
13#[cfg(unix)]
14const PARENT_MSG: &[u8; 8] = b"QDNF-E05";
15#[cfg(unix)]
16const CHILD_ACK: &[u8; 8] = b"ACK-E052";
17
18static SPAWNED: AtomicBool = AtomicBool::new(false);
19
20/// True after this process spawned a child, or this process *is* that child.
21pub fn two_os_process_ipc_executed() -> bool {
22    SPAWNED.load(Ordering::SeqCst) || is_child()
23}
24
25/// This module never claims two-host Ethernet.
26pub fn physical_two_host_from_this_module() -> bool {
27    false
28}
29
30/// Process-class evidence helper. Callers must not store PhysicalNetwork here.
31pub fn process_ipc_evidence(spawned_child: bool) -> InstrumentResult {
32    InstrumentResult {
33        instrument: Instrument::GraphOracle,
34        class: EvidenceClass::Process,
35        verdict: if spawned_child {
36            InstrumentVerdict::Pass
37        } else {
38            InstrumentVerdict::Fail
39        },
40        component_tables_pass: false,
41    }
42}
43
44fn is_child() -> bool {
45    match std::env::var(CHILD_ENV) {
46        Ok(v) => v == "1",
47        Err(_) => false,
48    }
49}
50
51#[cfg(unix)]
52fn io_err(err: std::io::Error) -> QdnfError {
53    match err.kind() {
54        std::io::ErrorKind::TimedOut | std::io::ErrorKind::WouldBlock => QdnfError::Expired,
55        std::io::ErrorKind::NotFound => QdnfError::Incomplete,
56        std::io::ErrorKind::PermissionDenied => QdnfError::Denied,
57        _ => QdnfError::PlatformUnsupported,
58    }
59}
60
61/// Parent binds a Unix stream socket, spawns this test binary as a child, and
62/// exchanges eight bytes. Evidence class is Process only.
63pub fn run_two_os_process_ipc() -> Result<InstrumentResult, QdnfError> {
64    if is_child() {
65        #[cfg(unix)]
66        {
67            child_exchange()?;
68            SPAWNED.store(true, Ordering::SeqCst);
69            return Ok(process_ipc_evidence(false));
70        }
71        #[cfg(not(unix))]
72        {
73            return Err(QdnfError::PlatformUnsupported);
74        }
75    }
76    #[cfg(not(unix))]
77    {
78        Err(QdnfError::PlatformUnsupported)
79    }
80    #[cfg(unix)]
81    {
82        parent_spawn_and_exchange()
83    }
84}
85
86#[cfg(unix)]
87fn child_exchange() -> Result<(), QdnfError> {
88    use std::io::{Read, Write};
89    use std::os::unix::net::UnixStream;
90    use std::time::{Duration, Instant};
91
92    let path = std::env::var(SOCK_ENV).map_err(|_| QdnfError::Incomplete)?;
93    let deadline = Instant::now() + Duration::from_secs(5);
94    let mut stream = loop {
95        match UnixStream::connect(&path) {
96            Ok(s) => break s,
97            Err(_) => {
98                if Instant::now() >= deadline {
99                    return Err(QdnfError::Expired);
100                }
101                std::thread::sleep(Duration::from_millis(5));
102            }
103        }
104    };
105    stream
106        .set_read_timeout(Some(Duration::from_secs(5)))
107        .map_err(io_err)?;
108    stream.write_all(PARENT_MSG).map_err(io_err)?;
109    let mut buf = [0u8; 8];
110    stream.read_exact(&mut buf).map_err(io_err)?;
111    if &buf != CHILD_ACK {
112        return Err(QdnfError::Malformed);
113    }
114    Ok(())
115}
116
117#[cfg(unix)]
118fn parent_spawn_and_exchange() -> Result<InstrumentResult, QdnfError> {
119    use std::io::{Read, Write};
120    use std::os::unix::net::UnixListener;
121    use std::process::Command;
122    use std::time::{Duration, Instant};
123
124    let dir = tempfile::TempDir::new().map_err(|_| QdnfError::PlatformUnsupported)?;
125    let sock = dir.path().join("qdnf-e05.sock");
126    let listener = UnixListener::bind(&sock).map_err(io_err)?;
127    listener.set_nonblocking(true).map_err(io_err)?;
128
129    let exe = std::env::current_exe().map_err(|_| QdnfError::Incomplete)?;
130    let test_name = std::thread::current()
131        .name()
132        .ok_or(QdnfError::Incomplete)?
133        .to_owned();
134    let mut child = Command::new(&exe)
135        .args(["--exact", &test_name, "--nocapture", "--test-threads", "1"])
136        .env(CHILD_ENV, "1")
137        .env(SOCK_ENV, &sock)
138        .stdout(std::process::Stdio::inherit())
139        .stderr(std::process::Stdio::inherit())
140        .spawn()
141        .map_err(|_| QdnfError::PlatformUnsupported)?;
142
143    let deadline = Instant::now() + Duration::from_secs(15);
144    let mut stream = loop {
145        match listener.accept() {
146            Ok((s, _)) => break s,
147            Err(e)
148                if e.kind() == std::io::ErrorKind::WouldBlock
149                    || e.kind() == std::io::ErrorKind::Interrupted =>
150            {
151                if Instant::now() >= deadline {
152                    let _ = child.kill();
153                    let _ = child.wait();
154                    return Err(QdnfError::Expired);
155                }
156                if let Ok(Some(status)) = child.try_wait() {
157                    if !status.success() {
158                        return Err(QdnfError::Denied);
159                    }
160                    return Err(QdnfError::Closed);
161                }
162                std::thread::sleep(Duration::from_millis(5));
163            }
164            Err(e) => {
165                let _ = child.kill();
166                let _ = child.wait();
167                return Err(io_err(e));
168            }
169        }
170    };
171    stream.set_nonblocking(false).map_err(io_err)?;
172    stream
173        .set_read_timeout(Some(Duration::from_secs(5)))
174        .map_err(io_err)?;
175    let mut buf = [0u8; 8];
176    stream.read_exact(&mut buf).map_err(io_err)?;
177    if &buf != PARENT_MSG {
178        let _ = child.kill();
179        let _ = child.wait();
180        return Err(QdnfError::Malformed);
181    }
182    stream.write_all(CHILD_ACK).map_err(io_err)?;
183    let status = child.wait().map_err(|_| QdnfError::Closed)?;
184    if !status.success() {
185        return Err(QdnfError::Denied);
186    }
187    SPAWNED.store(true, Ordering::SeqCst);
188    let evidence = process_ipc_evidence(true);
189    if evidence.class != EvidenceClass::Process {
190        return Err(QdnfError::Conflict);
191    }
192    if evidence.class == EvidenceClass::PhysicalNetwork {
193        return Err(QdnfError::Conflict);
194    }
195    Ok(evidence)
196}
197
198#[cfg(test)]
199mod tests {
200    use super::*;
201    use crate::net::qdnf::bearer::raw_ethernet::physical_two_host_qualified;
202
203    #[cfg(unix)]
204    #[test]
205    fn two_os_process_ipc_exchanges_bytes() {
206        assert!(!physical_two_host_from_this_module());
207        assert!(!physical_two_host_qualified());
208        let evidence = run_two_os_process_ipc().unwrap();
209        assert!(two_os_process_ipc_executed());
210        assert_eq!(evidence.class, EvidenceClass::Process);
211        assert_ne!(evidence.class, EvidenceClass::PhysicalNetwork);
212        assert!(!physical_two_host_from_this_module());
213        assert!(!physical_two_host_qualified());
214        if !is_child() {
215            assert_eq!(evidence.verdict, InstrumentVerdict::Pass);
216        }
217    }
218
219    #[test]
220    fn process_evidence_is_never_physical_network() {
221        let e = process_ipc_evidence(true);
222        assert_eq!(e.class, EvidenceClass::Process);
223        assert_ne!(e.class, EvidenceClass::PhysicalNetwork);
224        assert!(!physical_two_host_from_this_module());
225        assert!(!physical_two_host_qualified());
226    }
227}