safe_chains/registry/
dispatch.rs

1use crate::parse::Token;
2use crate::verdict::{SafetyLevel, Verdict};
3
4use super::policy::check_owned;
5use super::types::*;
6use super::{CMD_HANDLERS, SUB_HANDLERS};
7
8type HandlerMap = std::collections::HashMap<&'static str, super::HandlerFn>;
9
10fn dispatch_first_arg(tokens: &[Token], patterns: &[String], level: SafetyLevel) -> Verdict {
11    if tokens.len() == 2 && (tokens[1] == "--help" || tokens[1] == "-h") {
12        return Verdict::Allowed(SafetyLevel::Inert);
13    }
14    let Some(arg) = tokens.get(1) else {
15        return Verdict::Denied;
16    };
17    let arg_str = arg.as_str();
18    let matches = patterns.iter().any(|p| {
19        if let Some(prefix) = p.strip_suffix('*') {
20            arg_str.starts_with(prefix)
21        } else {
22            arg_str == p
23        }
24    });
25    if matches { Verdict::Allowed(level) } else { Verdict::Denied }
26}
27
28fn dispatch_require_any(
29    tokens: &[Token],
30    require_any: &[String],
31    policy: &OwnedPolicy,
32    level: SafetyLevel,
33    accept_bare_help: bool,
34) -> Verdict {
35    if tokens.len() == 2 {
36        let t = tokens[1].as_str();
37        if t == "--help" || t == "-h" || (accept_bare_help && t == "help") {
38            return Verdict::Allowed(SafetyLevel::Inert);
39        }
40    }
41    let has_required = tokens[1..].iter().any(|t| {
42        require_any.iter().any(|r| {
43            t == r.as_str() || (r.starts_with("--") && t.as_str().starts_with(&format!("{r}=")))
44        })
45    });
46    if has_required && check_owned(tokens, policy) {
47        Verdict::Allowed(level)
48    } else {
49        Verdict::Denied
50    }
51}
52
53fn skip_pre_flags(
54    tokens: &[Token],
55    pre_standalone: &[String],
56    pre_valued: &[String],
57) -> usize {
58    let mut i = 1;
59    while i < tokens.len() {
60        let t = &tokens[i];
61        if !t.starts_with('-') {
62            break;
63        }
64        if pre_valued.iter().any(|f| t == f.as_str()) {
65            i += 2;
66            continue;
67        }
68        if pre_valued.iter().any(|f| t.as_str().starts_with(&format!("{f}="))) {
69            i += 1;
70            continue;
71        }
72        if pre_standalone.iter().any(|f| t == f.as_str()) {
73            i += 1;
74            continue;
75        }
76        break;
77    }
78    i
79}
80
81fn dispatch_branching(
82    tokens: &[Token],
83    subs: &[SubSpec],
84    bare_flags: &[String],
85    bare_ok: bool,
86    pre_standalone: &[String],
87    pre_valued: &[String],
88    first_arg: &[String],
89    first_arg_level: SafetyLevel,
90) -> Verdict {
91    let start = skip_pre_flags(tokens, pre_standalone, pre_valued);
92    if start >= tokens.len() {
93        return if bare_ok { Verdict::Allowed(SafetyLevel::Inert) } else { Verdict::Denied };
94    }
95    let arg = tokens[start].as_str();
96    if bare_flags.is_empty() && matches!(arg, "--help" | "-h") {
97        if tokens.len() == start + 1 {
98            return Verdict::Allowed(SafetyLevel::Inert);
99        }
100        return Verdict::Denied;
101    }
102    if start + 1 == tokens.len() && bare_flags.iter().any(|f| f == arg) {
103        return Verdict::Allowed(SafetyLevel::Inert);
104    }
105    if let Some(sub) = subs.iter().find(|s| s.name == arg) {
106        return dispatch_kind(&tokens[start..], &sub.kind, &SUB_HANDLERS);
107    }
108    if !first_arg.is_empty() {
109        let matches = first_arg.iter().any(|p| {
110            if let Some(prefix) = p.strip_suffix('*') {
111                arg.starts_with(prefix)
112            } else {
113                arg == p
114            }
115        });
116        if matches {
117            return Verdict::Allowed(first_arg_level);
118        }
119    }
120    Verdict::Denied
121}
122
123fn dispatch_wrapper(
124    tokens: &[Token],
125    standalone: &[String],
126    valued: &[String],
127    positional_skip: usize,
128    separator: Option<&str>,
129    bare_ok: bool,
130) -> Verdict {
131    let mut i = 1;
132    while i < tokens.len() {
133        let t = &tokens[i];
134        if let Some(sep) = separator
135            && t == sep
136        {
137            i += 1;
138            break;
139        }
140        if !t.starts_with('-') {
141            break;
142        }
143        if valued.iter().any(|f| t == f.as_str()) {
144            i += 2;
145            continue;
146        }
147        if standalone.iter().any(|f| t == f.as_str()) {
148            i += 1;
149            continue;
150        }
151        i += 1;
152    }
153    for _ in 0..positional_skip {
154        if i >= tokens.len() {
155            return if bare_ok {
156                Verdict::Allowed(SafetyLevel::Inert)
157            } else {
158                Verdict::Denied
159            };
160        }
161        i += 1;
162    }
163    if i >= tokens.len() {
164        return if bare_ok {
165            Verdict::Allowed(SafetyLevel::Inert)
166        } else {
167            Verdict::Denied
168        };
169    }
170    let inner = shell_words::join(tokens[i..].iter().map(|t| t.as_str()));
171    crate::command_verdict(&inner)
172}
173
174fn dispatch_kind(tokens: &[Token], kind: &DispatchKind, handlers: &HandlerMap) -> Verdict {
175    match kind {
176        DispatchKind::Policy { policy, level } => {
177            if check_owned(tokens, policy) {
178                Verdict::Allowed(*level)
179            } else {
180                Verdict::Denied
181            }
182        }
183        DispatchKind::FirstArg { patterns, level } => {
184            dispatch_first_arg(tokens, patterns, *level)
185        }
186        DispatchKind::RequireAny { require_any, policy, level, accept_bare_help } => {
187            dispatch_require_any(tokens, require_any, policy, *level, *accept_bare_help)
188        }
189        DispatchKind::Branching {
190            subs, bare_flags, bare_ok, pre_standalone, pre_valued, first_arg, first_arg_level,
191        } => {
192            dispatch_branching(
193                tokens, subs, bare_flags, *bare_ok, pre_standalone, pre_valued,
194                first_arg, *first_arg_level,
195            )
196        }
197        DispatchKind::WriteFlagged { policy, base_level, write_flags } => {
198            if !check_owned(tokens, policy) {
199                return Verdict::Denied;
200            }
201            let has_write = tokens[1..].iter().any(|t| {
202                write_flags.iter().any(|f| t == f.as_str() || t.as_str().starts_with(&format!("{f}=")))
203            });
204            if has_write {
205                Verdict::Allowed(SafetyLevel::SafeWrite)
206            } else {
207                Verdict::Allowed(*base_level)
208            }
209        }
210        DispatchKind::DelegateAfterSeparator { separator } => {
211            let sep_pos = tokens[1..].iter().position(|t| t == separator.as_str());
212            let Some(pos) = sep_pos else {
213                return Verdict::Denied;
214            };
215            let inner_start = pos + 2;
216            if inner_start >= tokens.len() {
217                return Verdict::Denied;
218            }
219            let inner = shell_words::join(tokens[inner_start..].iter().map(|t| t.as_str()));
220            crate::command_verdict(&inner)
221        }
222        DispatchKind::DelegateSkip { skip } => {
223            if tokens.len() <= *skip {
224                return Verdict::Denied;
225            }
226            let inner = shell_words::join(tokens[*skip..].iter().map(|t| t.as_str()));
227            crate::command_verdict(&inner)
228        }
229        DispatchKind::Wrapper {
230            standalone, valued, positional_skip, separator, bare_ok,
231        } => {
232            dispatch_wrapper(tokens, standalone, valued, *positional_skip, separator.as_deref(), *bare_ok)
233        }
234        DispatchKind::Custom { handler_name } => {
235            handlers
236                .get(handler_name.as_str())
237                .map(|f| f(tokens))
238                .unwrap_or(Verdict::Denied)
239        }
240    }
241}
242
243pub fn dispatch_spec(tokens: &[Token], spec: &CommandSpec) -> Verdict {
244    dispatch_kind(tokens, &spec.kind, &CMD_HANDLERS)
245}
safe_chains/registry/dispatch.rs

safe_chains/registry/
dispatch.rs
