qualia_core_db/net/qdnf/harness/
two_process.rs1use 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
20pub fn two_os_process_ipc_executed() -> bool {
22 SPAWNED.load(Ordering::SeqCst) || is_child()
23}
24
25pub fn physical_two_host_from_this_module() -> bool {
27 false
28}
29
30pub 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
61pub 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}