1use std::collections::BTreeMap;
7use std::sync::{Mutex, PoisonError};
8
9use dive_ir::{StdOp, StdSupport};
10
11use crate::HostError;
12
13pub const MAX_INPUT_BYTES: usize = 1 << 20;
15pub const MAX_INPUT_RECORDS: usize = 256;
17pub const MAX_ENV_ENTRIES: usize = 4096;
19
20#[derive(Clone, Copy, Debug, Default, PartialEq, Eq, Hash)]
23pub struct HostAccess {
24 pub env: bool,
26 pub files: bool,
28 pub exec: bool,
30}
31
32impl HostAccess {
33 pub const NONE: Self = Self {
35 env: false,
36 files: false,
37 exec: false,
38 };
39
40 pub fn parse(text: &str) -> Result<Self, &'static str> {
51 let mut access = Self::NONE;
52 for name in text.split(',') {
53 let slot = match name {
54 "env" => &mut access.env,
55 "files" => &mut access.files,
56 "exec" => &mut access.exec,
57 _ => return Err("--allow-io expects comma-separated env,files,exec categories"),
58 };
59 if *slot {
60 return Err("--allow-io repeats a category");
61 }
62 *slot = true;
63 }
64 Ok(access)
65 }
66
67 #[must_use]
69 pub fn names(self) -> Vec<&'static str> {
70 [
71 (self.env, "env"),
72 (self.files, "files"),
73 (self.exec, "exec"),
74 ]
75 .into_iter()
76 .filter_map(|(yes, name)| yes.then_some(name))
77 .collect()
78 }
79
80 #[must_use]
82 pub const fn is_empty(self) -> bool {
83 !self.env && !self.files && !self.exec
84 }
85
86 #[must_use]
89 pub fn allows(self, op: StdOp) -> bool {
90 self.denied(op).is_none()
91 }
92
93 pub(crate) fn denied(self, op: StdOp) -> Option<&'static str> {
94 let (allowed, category) = match op {
95 StdOp::IoUtilsIOEnv => (self.env, "env"),
96 StdOp::IoUtilsIOExec
97 | StdOp::IoUtilsIOEnvExec
98 | StdOp::IoUtilsIOExecTemplate
99 | StdOp::IoUtilsIOEnvExecTemplate => (self.exec, "exec"),
100 _ if op.support() == StdSupport::Io => (self.files, "files"),
101 _ => return None,
102 };
103 (!allowed).then_some(category)
104 }
105}
106
107#[derive(Clone, Debug, PartialEq, Eq)]
109pub enum InputRequest {
110 Environment,
112 TextFile(String),
114}
115
116#[derive(Clone, Debug, PartialEq, Eq)]
118pub enum InputResponse {
119 Environment(BTreeMap<String, String>),
121 Text(String),
123}
124
125#[derive(Clone, Debug, PartialEq, Eq)]
127pub struct InputRecord {
128 pub request: InputRequest,
130 pub response: InputResponse,
132}
133
134impl InputRecord {
135 #[must_use]
137 pub fn bytes(&self) -> usize {
138 let path = match &self.request {
139 InputRequest::Environment => 0,
140 InputRequest::TextFile(path) => path.len(),
141 };
142 path.saturating_add(match &self.response {
143 InputResponse::Environment(entries) => {
144 entries.iter().fold(0usize, |n, (key, value)| {
145 n.saturating_add(key.len()).saturating_add(value.len())
146 })
147 }
148 InputResponse::Text(text) => text.len(),
149 })
150 }
151}
152
153#[derive(Clone, Debug, Default, PartialEq, Eq)]
155pub struct RecordedInputs {
156 pub grants: HostAccess,
158 pub records: Vec<InputRecord>,
160}
161
162pub trait InputSource: Send + Sync + std::fmt::Debug {
164 fn request(&self, request: &InputRequest) -> Result<InputResponse, HostError>;
169 fn finish_binding(&self) -> Result<(), HostError>;
174 fn recorded(&self) -> RecordedInputs;
176}
177
178impl RecordedInputs {
179 pub fn validate(&self) -> Result<(), HostError> {
184 if self.records.len() > MAX_INPUT_RECORDS
185 || self
186 .records
187 .iter()
188 .fold(0usize, |n, r| n.saturating_add(r.bytes()))
189 > MAX_INPUT_BYTES
190 {
191 return Err(input_error("recorded external input bounds"));
192 }
193 let mut environment = None;
194 for record in &self.records {
195 match (&record.request, &record.response) {
196 (InputRequest::Environment, InputResponse::Environment(entries))
197 if self.grants.env =>
198 {
199 if entries.len() > MAX_ENV_ENTRIES {
200 return Err(input_error("environment entry limit"));
201 }
202 if environment.is_some_and(|previous| previous != entries) {
203 return Err(input_error("recorded IOEnv must retain one environment"));
204 }
205 environment = Some(entries);
206 }
207 (InputRequest::TextFile(_), InputResponse::Text(_)) if self.grants.files => {}
208 _ => return Err(input_error("recorded input kind or category mismatch")),
209 }
210 }
211 Ok(())
212 }
213}
214
215#[derive(Debug)]
217pub struct InputReplay {
218 inputs: RecordedInputs,
219 cursor: Mutex<(usize, bool, Option<HostError>)>,
220}
221
222impl InputReplay {
223 pub fn new(inputs: RecordedInputs) -> Result<Self, HostError> {
241 inputs.validate()?;
242 Ok(Self {
243 inputs,
244 cursor: Mutex::new((0, false, None)),
245 })
246 }
247
248 pub fn request(&self, request: &InputRequest) -> Result<InputResponse, HostError> {
253 let mut cursor = self.cursor.lock().unwrap_or_else(PoisonError::into_inner);
254 if let Some(error) = &cursor.2 {
255 return Err(error.clone());
256 }
257 let record = self.inputs.records.get(cursor.0);
258 let result = if cursor.1 {
259 Err(input_error("external input outside source binding"))
260 } else if let Some(record) = record {
261 if &record.request == request {
262 Ok(record.response.clone())
263 } else {
264 Err(input_error(
265 "recorded input does not match the next source operation and arguments",
266 ))
267 }
268 } else {
269 Err(input_error("missing recorded source input"))
270 };
271 match &result {
272 Ok(_) => cursor.0 += 1,
273 Err(error) => cursor.2 = Some(error.clone()),
274 }
275 result
276 }
277
278 pub fn finish_binding(&self) -> Result<(), HostError> {
283 let mut cursor = self.cursor.lock().unwrap_or_else(PoisonError::into_inner);
284 cursor.1 = true;
285 if let Some(error) = &cursor.2 {
286 return Err(error.clone());
287 }
288 if cursor.0 != self.inputs.records.len() {
289 let error = input_error("extra recorded inputs not demanded by source binding");
290 cursor.2 = Some(error.clone());
291 return Err(error);
292 }
293 Ok(())
294 }
295
296 #[must_use]
298 pub fn failure(&self) -> Option<HostError> {
299 self.cursor
300 .lock()
301 .unwrap_or_else(PoisonError::into_inner)
302 .2
303 .clone()
304 }
305}
306
307impl InputSource for InputReplay {
308 fn request(&self, request: &InputRequest) -> Result<InputResponse, HostError> {
309 Self::request(self, request)
310 }
311 fn finish_binding(&self) -> Result<(), HostError> {
312 Self::finish_binding(self)
313 }
314 fn recorded(&self) -> RecordedInputs {
315 self.inputs.clone()
316 }
317}
318
319impl crate::Host for InputReplay {
320 fn input(&self, request: &InputRequest) -> Option<Result<InputResponse, HostError>> {
321 Some(self.request(request))
322 }
323}
324
325#[must_use]
327pub fn input_error(message: &str) -> HostError {
328 HostError {
329 code: 0,
330 message: format!("external inputs: {message}"),
331 }
332}