use crate::ast::*;
use crate::error::ParseError;
use crate::glob::FileRulePattern;
use crate::lexer::Cursor;
pub(crate) fn parse_policy(source: &str) -> Result<Policy, ParseError> {
let mut p = Parser {
cur: Cursor::new(source),
};
p.parse_policy()
}
struct Parser<'a> {
cur: Cursor<'a>,
}
type BodyParts = (
Vec<VariableAssignment>,
Vec<IncludeRule>,
Vec<AliasRule>,
Vec<Rule>,
Vec<Hat>,
);
#[derive(Default)]
struct Qual {
q: Qualifiers,
owner: bool,
group: Option<String>,
}
impl<'a> Parser<'a> {
fn parse_policy(&mut self) -> Result<Policy, ParseError> {
let mut items = Vec::new();
loop {
self.cur.skip_trivia();
if self.cur.peek().is_none() {
break;
}
if self.cur.starts_with("@{") {
items.push(PolicyItem::Variable(self.parse_variable_assignment()?));
continue;
}
if self.cur.starts_with("#include") {
self.consume_literal("#include");
items.push(PolicyItem::Include(self.parse_include_body()?));
continue;
}
let start = self.cur.pos();
let Some(word) = self.cur.read_plain_word() else {
if self.cur.peek() == Some('"') {
self.cur.set_pos(start);
items.push(PolicyItem::Profile(self.parse_profile()?));
continue;
}
self.skip_line();
continue;
};
match word.as_str() {
"include" => items.push(PolicyItem::Include(self.parse_include_body()?)),
"alias" => items.push(PolicyItem::Alias(self.parse_alias()?)),
"abi" => items.push(PolicyItem::Abi(self.parse_abi()?)),
"profile" => items.push(PolicyItem::Profile(self.parse_profile()?)),
_ if word.starts_with('/') || word.starts_with('"') => {
self.cur.set_pos(start);
items.push(PolicyItem::Profile(self.parse_profile()?));
}
_ => {
let (line, col) = crate::error::line_col(self.cur.source(), start);
self.cur.set_pos(start);
let text = self.cur.read_raw_until_terminator();
items.push(PolicyItem::Raw(RawItem { text, line, col }));
}
}
}
Ok(Policy { items })
}
fn consume_literal(&mut self, s: &str) {
for _ in 0..s.len() {
self.cur.bump();
}
}
fn skip_line(&mut self) {
while let Some(c) = self.cur.peek() {
if c == '\n' {
break;
}
self.cur.bump();
}
}
fn parse_variable_assignment(&mut self) -> Result<VariableAssignment, ParseError> {
let start = self.cur.pos();
let token = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error_at(start, "expected `@{VAR}`"))?;
let name = token
.strip_prefix("@{")
.and_then(|t| t.strip_suffix('}'))
.ok_or_else(|| self.cur.error_at(start, "expected `@{VAR}`"))?
.to_string();
if name.is_empty() {
return Err(self.cur.error_at(start, "empty variable name"));
}
self.cur.skip_trivia();
let append = if self.cur.starts_with("+=") {
self.cur.bump();
self.cur.bump();
true
} else if self.cur.consume_if('=') {
false
} else {
return Err(self
.cur
.error("expected `=` or `+=` in variable assignment"));
};
let mut values = Vec::new();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') => {
self.cur.bump();
break;
}
None | Some('}') => break,
_ => {
let v = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected variable value"))?;
values.push(v);
}
}
}
Ok(VariableAssignment {
name,
append,
values,
})
}
fn parse_alias(&mut self) -> Result<AliasRule, ParseError> {
self.cur.skip_trivia();
let oldname = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected path in alias rule"))?;
self.expect_arrow()?;
self.cur.skip_trivia();
let newname = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected rewritten path in alias rule"))?;
self.expect_comma()?;
Ok(AliasRule { oldname, newname })
}
fn parse_include_body(&mut self) -> Result<IncludeRule, ParseError> {
self.cur.skip_trivia();
let if_exists = if self.cur.starts_with("if") {
let _ = self.cur.read_plain_word(); self.cur.skip_trivia();
let _ = self.cur.read_plain_word(); self.cur.skip_trivia();
true
} else {
false
};
let start = self.cur.pos();
let token = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error_at(start, "expected path after `include`"))?;
let (magic, path) = match token.strip_prefix('<').and_then(|t| t.strip_suffix('>')) {
Some(inner) => (true, inner.to_string()),
None => (false, token),
};
Ok(IncludeRule {
if_exists,
magic,
path,
})
}
fn parse_abi(&mut self) -> Result<AbiRule, ParseError> {
self.cur.skip_trivia();
let start = self.cur.pos();
let token = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error_at(start, "expected path after `abi`"))?;
let (magic, path) = match token.strip_prefix('<').and_then(|t| t.strip_suffix('>')) {
Some(inner) => (true, inner.to_string()),
None => (false, token),
};
self.expect_comma()?;
Ok(AbiRule { magic, path })
}
fn parse_profile(&mut self) -> Result<Profile, ParseError> {
let save = self.cur.pos();
if let Some(w) = self.cur.read_plain_word() {
if w != "profile" {
self.cur.set_pos(save);
}
}
let (name, attachment, flags) = self.parse_profile_header()?;
let (variables, includes, aliases, rules, hats) = self.parse_body()?;
Ok(Profile {
name,
attachment,
flags,
variables,
includes,
aliases,
rules,
hats,
})
}
fn parse_profile_header(
&mut self,
) -> Result<(String, Option<FileRulePattern>, Vec<Flag>), ParseError> {
self.cur.skip_trivia();
let start = self.cur.pos();
let was_quoted = self.cur.peek() == Some('"');
let first = self.cur.read_value()?.ok_or_else(|| {
self.cur
.error_at(start, "expected profile name after `profile`")
})?;
let first_is_attachment = was_quoted
|| first.starts_with('/')
|| first.starts_with("@{")
|| FileRulePattern::parse(&first)
.map(|p| p.is_meta())
.unwrap_or(true);
let mut name = first.clone();
let mut attachment: Option<FileRulePattern> = None;
let mut flags: Option<Vec<Flag>> = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some('{') => break,
Some(_) => {
let save = self.cur.pos();
if let Some(w) = self.cur.read_plain_word() {
if w == "flags" {
flags = Some(self.parse_flags()?);
continue;
}
}
self.cur.set_pos(save);
if attachment.is_some() {
return Err(self.cur.error("too many tokens in profile header"));
}
if first_is_attachment {
return Err(self
.cur
.error("expected `flags` or `{` after a profile attachment"));
}
let t2 = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected `{` or profile attachment"))?;
name = first.clone();
attachment = Some(FileRulePattern::parse(&t2)?);
}
None => {
return Err(self.cur.error("unexpected end of file in profile header"));
}
}
}
if first_is_attachment {
name = first.clone();
attachment = Some(FileRulePattern::parse(&first)?);
}
self.expect_open_brace()?;
Ok((name, attachment, flags.unwrap_or_default()))
}
fn parse_hat(&mut self) -> Result<Hat, ParseError> {
self.cur.skip_trivia();
let start = self.cur.pos();
let name_token = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error_at(start, "expected hat name"))?;
let name = name_token
.strip_prefix('^')
.unwrap_or(&name_token)
.to_string();
let flags = self.parse_optional_flags()?;
self.expect_open_brace()?;
let (variables, includes, aliases, rules, hats) = self.parse_body()?;
Ok(Hat {
is_subprofile: false,
name,
attachment: None,
flags,
variables,
includes,
aliases,
rules,
hats,
})
}
fn parse_subprofile(&mut self) -> Result<Hat, ParseError> {
let (name, attachment, flags) = self.parse_profile_header()?;
let (variables, includes, aliases, rules, hats) = self.parse_body()?;
Ok(Hat {
is_subprofile: true,
name,
attachment,
flags,
variables,
includes,
aliases,
rules,
hats,
})
}
fn parse_optional_flags(&mut self) -> Result<Vec<Flag>, ParseError> {
self.cur.skip_trivia();
let save = self.cur.pos();
if let Some(w) = self.cur.read_plain_word() {
if w == "flags" {
return self.parse_flags();
}
}
self.cur.set_pos(save);
Ok(vec![])
}
fn parse_flags(&mut self) -> Result<Vec<Flag>, ParseError> {
self.cur.skip_trivia();
self.expect('=')?;
self.cur.skip_trivia();
let mut flags = Vec::new();
if self.cur.peek() == Some('(') {
self.cur.bump();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(')') => {
self.cur.bump();
break;
}
Some(',') => {
self.cur.bump();
}
None => {
return Err(self.cur.error("unterminated flags list"));
}
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected flag"))?;
flags.push(split_flag(&t));
}
}
}
} else {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected flag after `flags=`"))?;
flags.push(split_flag(&t));
}
Ok(flags)
}
fn parse_body(&mut self) -> Result<BodyParts, ParseError> {
let mut variables = Vec::new();
let mut includes = Vec::new();
let mut aliases = Vec::new();
let mut rules = Vec::new();
let mut hats = Vec::new();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
None => {
return Err(self.cur.error("unclosed `{` (missing `}`)"));
}
Some('}') => {
self.cur.bump();
break;
}
Some('#') if self.cur.starts_with("#include") => {
self.consume_literal("#include");
includes.push(self.parse_include_body()?);
}
Some('@') if self.cur.starts_with("@{") => {
let save = self.cur.pos();
let _ = self.cur.read_value()?;
self.cur.skip_trivia();
let is_assignment = self.cur.starts_with("+=") || self.cur.peek() == Some('=');
self.cur.set_pos(save);
if is_assignment {
variables.push(self.parse_variable_assignment()?);
} else {
let rule_start = self.cur.pos();
rules.push(self.parse_one_rule(rule_start)?);
}
}
Some('^') => {
hats.push(self.parse_hat()?);
}
Some(_) => {
let save = self.cur.pos();
let word = self.cur.read_plain_word().unwrap_or_default();
match word.as_str() {
"profile" => hats.push(self.parse_subprofile()?),
"hat" => hats.push(self.parse_hat()?),
"include" => includes.push(self.parse_include_body()?),
"alias" => aliases.push(self.parse_alias()?),
_ => {
self.cur.set_pos(save);
let rule_start = self.cur.pos();
rules.push(self.parse_one_rule(rule_start)?);
}
}
}
}
}
Ok((variables, includes, aliases, rules, hats))
}
fn parse_one_rule(&mut self, rule_start: usize) -> Result<Rule, ParseError> {
let (start_line, start_col) = crate::error::line_col(self.cur.source(), rule_start);
match self.parse_rule_inner() {
Ok(rule) => {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') => {
self.cur.bump();
Ok(rule)
}
Some('}') => Ok(rule),
_ => {
self.cur.set_pos(rule_start);
let text = self.cur.read_raw_until_terminator();
Ok(Rule::Raw(RawRule {
text,
line: start_line,
col: start_col,
note: Some("rule is missing a terminating comma".to_string()),
}))
}
}
}
Err(e) => {
self.cur.set_pos(rule_start);
let text = self.cur.read_raw_until_terminator();
Ok(Rule::Raw(RawRule {
text,
line: e.line,
col: e.col,
note: Some(e.message.clone()),
}))
}
}
}
fn parse_rule_inner(&mut self) -> Result<Rule, ParseError> {
let qual = self.parse_qualifiers()?;
let save = self.cur.pos();
let word = self.cur.read_plain_word().unwrap_or_default();
match word.as_str() {
"capability" => self.parse_capability(qual),
"network" => self.parse_network(qual),
"mount" | "remount" | "umount" => self.parse_mount(qual, &word),
"pivot_root" => self.parse_pivot_root(qual),
"link" => self.parse_link(qual),
"change_profile" => self.parse_change_profile(qual),
"set" => self.parse_set(qual),
"dbus" => self.parse_dbus(qual),
"unix" => self.parse_unix(qual),
"mqueue" => self.parse_mqueue(qual),
"userns" => self.parse_userns(qual),
"io_uring" => self.parse_io_uring(qual),
"signal" => self.parse_signal(qual),
"ptrace" => self.parse_ptrace(qual),
"all" => Ok(Rule::All(AllRule { qualifiers: qual.q })),
"file" => self.parse_file_rule(qual, true),
_ => {
self.cur.set_pos(save);
self.parse_file_rule(qual, false)
}
}
}
fn parse_qualifiers(&mut self) -> Result<Qual, ParseError> {
let mut qual = Qual::default();
loop {
self.cur.skip_trivia();
let save = self.cur.pos();
let word = match self.cur.read_plain_word() {
Some(w) => w,
None => break,
};
match word.as_str() {
"audit" => qual.q.audit = true,
"deny" => qual.q.deny = true,
"allow" => qual.q.allow = true,
"owner" => qual.owner = true,
"group" => {
self.cur.skip_trivia();
self.expect('=')?;
self.cur.skip_trivia();
let g = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected group name"))?;
qual.group = Some(g);
}
"priority" => {
self.cur.skip_trivia();
self.expect('=')?;
self.cur.skip_trivia();
let n = self
.cur
.read_plain_word()
.ok_or_else(|| self.cur.error("expected priority value"))?;
let n: u64 = n
.parse()
.map_err(|_| self.cur.error("invalid priority value"))?;
qual.q.priority = Some(n);
}
_ => {
self.cur.set_pos(save);
break;
}
}
}
Ok(qual)
}
fn parse_capability(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut capabilities = Vec::new();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected capability name"))?;
capabilities.push(t);
}
}
}
Ok(Rule::Capability(CapabilityRule {
qualifiers: qual.q,
capabilities,
}))
}
fn parse_network(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut access = Vec::new();
let mut domain = None;
let mut network_type = None;
let mut protocol = None;
let mut conditions = Vec::new();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
Some('(') => {
self.cur.bump();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(')') => {
self.cur.bump();
break;
}
Some(',') => {
self.cur.bump();
}
None => {
return Err(self.cur.error("unterminated network access list"));
}
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected access"))?;
if let Some(a) = classify_network_access(&t) {
access.push(a);
}
}
}
}
}
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected network rule token"))?;
if let Some(a) = classify_network_access(&t) {
access.push(a);
} else if let Some(v) = t.strip_prefix("ip=") {
conditions.push(("ip".to_string(), v.to_string()));
} else if let Some(v) = t.strip_prefix("port=") {
conditions.push(("port".to_string(), v.to_string()));
} else if matches!(
t.as_str(),
"stream" | "dgram" | "seqpacket" | "rdm" | "raw" | "packet"
) {
network_type = Some(t);
} else if matches!(t.as_str(), "tcp" | "udp" | "icmp") {
protocol = Some(t);
} else {
domain = Some(t);
}
}
}
}
Ok(Rule::Network(NetworkRule {
qualifiers: qual.q,
access,
domain,
network_type,
protocol,
conditions,
}))
}
fn parse_mount(&mut self, qual: Qual, keyword: &str) -> Result<Rule, ParseError> {
let operation = match keyword {
"remount" => MountOp::Remount,
"umount" => MountOp::Umount,
_ => MountOp::Mount,
};
let mut fstype = None;
let mut options = None;
let mut source = None;
let mut mount_point = None;
let mut target = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected mount rule token"))?;
if t == "->" {
self.cur.skip_trivia();
let name = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected profile name after `->`"))?;
target = Some(ProfileTarget { name });
} else if let Some(v) = t.strip_prefix("fstype=") {
fstype = Some(self.parse_value_condition(v, "fstype")?);
} else if let Some(v) = t.strip_prefix("vfstype=") {
fstype = Some(self.parse_value_condition(v, "vfstype")?);
} else if let Some(v) = t.strip_prefix("options=") {
options = Some(self.parse_value_condition(v, "options")?);
} else if t == "fstype" || t == "vfstype" {
fstype = Some(self.parse_in_condition("fstype")?);
} else if t == "options" {
options = Some(self.parse_in_condition("options")?);
} else {
let glob = FileRulePattern::parse(&t)?;
if source.is_none() {
source = Some(glob);
} else if mount_point.is_none() {
mount_point = Some(glob);
} else {
return Err(self.cur.error("too many paths in mount rule"));
}
}
}
}
}
Ok(Rule::Mount(MountRule {
qualifiers: qual.q,
operation,
fstype,
options,
source,
mount_point,
target,
}))
}
fn parse_value_condition(
&mut self,
inline: &str,
name: &str,
) -> Result<ValueCondition, ParseError> {
if !inline.is_empty() {
return Ok(ValueCondition {
name: name.to_string(),
in_list: false,
values: vec![inline.to_string()],
});
}
if self.cur.peek() == Some('(') {
return self.parse_in_condition(name);
}
self.cur.skip_trivia();
let v = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected value after `=`"))?;
Ok(ValueCondition {
name: name.to_string(),
in_list: false,
values: vec![v],
})
}
fn parse_in_condition(&mut self, name: &str) -> Result<ValueCondition, ParseError> {
self.cur.skip_trivia();
let save = self.cur.pos();
if let Some(w) = self.cur.read_plain_word() {
if w != "in" {
self.cur.set_pos(save);
}
}
self.cur.skip_trivia();
self.expect('(')?;
let mut values = Vec::new();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(')') => {
self.cur.bump();
break;
}
Some(',') => {
self.cur.bump();
}
None => return Err(self.cur.error("unterminated `in (...)` list")),
_ => {
let v = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected list value"))?;
values.push(v);
}
}
}
Ok(ValueCondition {
name: name.to_string(),
in_list: true,
values,
})
}
fn parse_pivot_root(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut old_root = None;
let mut new_root = None;
let mut target = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected pivot_root token"))?;
if t == "->" {
self.cur.skip_trivia();
let name = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected profile name after `->`"))?;
target = Some(ProfileTarget { name });
} else if let Some(v) = t.strip_prefix("oldroot=") {
old_root = Some(FileRulePattern::parse(v)?);
} else if new_root.is_some() {
return Err(self.cur.error("too many paths in pivot_root rule"));
} else {
new_root = Some(FileRulePattern::parse(&t)?);
}
}
}
}
Ok(Rule::PivotRoot(PivotRootRule {
qualifiers: qual.q,
old_root,
new_root,
target,
}))
}
fn parse_link(&mut self, qual: Qual) -> Result<Rule, ParseError> {
self.cur.skip_trivia();
let mut subset = false;
let save = self.cur.pos();
if let Some(w) = self.cur.read_plain_word() {
if w == "subset" {
subset = true;
} else {
self.cur.set_pos(save);
}
}
self.cur.skip_trivia();
let oldname = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected path in link rule"))?;
self.expect_arrow()?;
self.cur.skip_trivia();
let newname = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected path after `->` in link rule"))?;
Ok(Rule::Link(LinkRule {
qualifiers: qual.q,
owner: qual.owner,
subset,
oldname: FileRulePattern::parse(&oldname)?,
newname: FileRulePattern::parse(&newname)?,
}))
}
fn parse_change_profile(&mut self, qual: Qual) -> Result<Rule, ParseError> {
self.cur.skip_trivia();
let mut safe = None;
let save = self.cur.pos();
if let Some(w) = self.cur.read_plain_word() {
match w.as_str() {
"safe" => safe = Some(true),
"unsafe" => safe = Some(false),
_ => {
self.cur.set_pos(save);
}
}
}
self.cur.skip_trivia();
let executable = self.cur.read_value()?.ok_or_else(|| {
self.cur
.error("expected executable path in change_profile rule")
})?;
let mut target = None;
self.cur.skip_trivia();
if self.cur.starts_with("->") {
self.cur.bump();
self.cur.bump();
self.cur.skip_trivia();
let name = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected profile name after `->`"))?;
target = Some(ProfileTarget { name });
}
Ok(Rule::ChangeProfile(ChangeProfileRule {
qualifiers: qual.q,
safe,
executable: FileRulePattern::parse(&executable)?,
target,
}))
}
fn parse_set(&mut self, qual: Qual) -> Result<Rule, ParseError> {
self.cur.skip_trivia();
let kw = self
.cur
.read_plain_word()
.ok_or_else(|| self.cur.error("expected `rlimit` after `set`"))?;
if kw != "rlimit" {
return Err(self.cur.error("expected `rlimit` after `set`"));
}
self.cur.skip_trivia();
let rlimit = self
.cur
.read_plain_word()
.ok_or_else(|| self.cur.error("expected rlimit name"))?;
let mut op = None;
let mut value = None;
self.cur.skip_trivia();
if self.cur.starts_with("<=") {
self.cur.bump();
self.cur.bump();
op = Some(RelOp::LessEqual);
} else if self.cur.consume_if('<') {
op = Some(RelOp::Less);
}
if op.is_some() {
self.cur.skip_trivia();
let v = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected rlimit value"))?;
value = Some(parse_limit_value(&v)?);
}
Ok(Rule::Rlimit(RlimitRule {
qualifiers: qual.q,
rlimit,
op,
value,
}))
}
fn parse_dbus(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut access = Vec::new();
let mut bus = None;
let mut path = None;
let mut interface = None;
let mut member = None;
let mut peer = None;
let mut label = None;
let mut name = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
Some('(') => {
self.cur.bump();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(')') => {
self.cur.bump();
break;
}
Some(',') => {
self.cur.bump();
}
None => return Err(self.cur.error("unterminated dbus access list")),
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected access"))?;
access.push(t);
}
}
}
}
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected dbus rule token"))?;
self.apply_dbus_token(
t,
&mut access,
&mut bus,
&mut path,
&mut interface,
&mut member,
&mut peer,
&mut label,
&mut name,
)?;
}
}
}
Ok(Rule::Dbus(DbusRule {
qualifiers: qual.q,
access,
bus,
path,
interface,
member,
peer,
label,
name,
}))
}
#[allow(clippy::too_many_arguments)]
fn apply_dbus_token(
&mut self,
t: String,
access: &mut Vec<String>,
bus: &mut Option<String>,
path: &mut Option<FileRulePattern>,
interface: &mut Option<String>,
member: &mut Option<String>,
peer: &mut Option<PeerCondition>,
label: &mut Option<FileRulePattern>,
name: &mut Option<String>,
) -> Result<(), ParseError> {
if let Some(v) = t.strip_prefix("bus=") {
*bus = Some(v.to_string());
} else if let Some(v) = t.strip_prefix("path=") {
*path = Some(FileRulePattern::parse(v)?);
} else if let Some(v) = t.strip_prefix("interface=") {
*interface = Some(v.to_string());
} else if let Some(v) = t.strip_prefix("member=") {
*member = Some(v.to_string());
} else if let Some(v) = t.strip_prefix("label=") {
*label = Some(FileRulePattern::parse(v)?);
} else if let Some(v) = t.strip_prefix("name=") {
*name = Some(v.to_string());
} else if t == "peer" || t == "peer=" {
*peer = Some(self.parse_peer_condition()?);
} else {
access.push(t);
}
Ok(())
}
fn parse_peer_condition(&mut self) -> Result<PeerCondition, ParseError> {
self.cur.skip_trivia();
self.expect('(')?;
let mut peer = PeerCondition::default();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(')') => {
self.cur.bump();
break;
}
Some(',') => {
self.cur.bump();
}
None => return Err(self.cur.error("unterminated `peer=(...)` condition")),
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected peer attribute"))?;
if let Some(v) = t.strip_prefix("name=") {
peer.name = Some(v.to_string());
} else if let Some(v) = t.strip_prefix("label=") {
peer.label = Some(v.to_string());
} else if let Some(v) = t.strip_prefix("addr=") {
peer.addr = Some(FileRulePattern::parse(v)?);
}
}
}
}
Ok(peer)
}
fn parse_unix(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut access = Vec::new();
let mut type_cond = None;
let mut protocol = None;
let mut addr = None;
let mut label = None;
let mut attr = None;
let mut opt = None;
let mut peer = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
Some('(') => {
self.cur.bump();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(')') => {
self.cur.bump();
break;
}
Some(',') => {
self.cur.bump();
}
None => return Err(self.cur.error("unterminated unix access list")),
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected access"))?;
access.push(t);
}
}
}
}
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected unix rule token"))?;
if let Some(v) = t.strip_prefix("type=") {
type_cond = Some(v.to_string());
} else if let Some(v) = t.strip_prefix("protocol=") {
protocol = Some(v.to_string());
} else if let Some(v) = t.strip_prefix("addr=") {
addr = Some(FileRulePattern::parse(v)?);
} else if let Some(v) = t.strip_prefix("label=") {
label = Some(FileRulePattern::parse(v)?);
} else if let Some(v) = t.strip_prefix("attr=") {
attr = Some(FileRulePattern::parse(v)?);
} else if let Some(v) = t.strip_prefix("opt=") {
opt = Some(FileRulePattern::parse(v)?);
} else if t == "peer" || t == "peer=" {
peer = Some(self.parse_peer_condition()?);
} else {
access.push(t);
}
}
}
}
Ok(Rule::Unix(UnixRule {
qualifiers: qual.q,
access,
type_cond,
protocol,
addr,
label,
attr,
opt,
peer,
}))
}
fn parse_mqueue(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut access = Vec::new();
let mut mq_type = None;
let mut label = None;
let mut name = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
Some('(') => self.parse_paren_access(&mut access)?,
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected mqueue token"))?;
if let Some(v) = t.strip_prefix("type=") {
mq_type = Some(v.to_string());
} else if let Some(v) = t.strip_prefix("label=") {
label = Some(FileRulePattern::parse(v)?);
} else if let Some(v) = t.strip_prefix("name=") {
name = Some(FileRulePattern::parse(v)?);
} else {
access.push(t);
}
}
}
}
Ok(Rule::Mqueue(MqueueRule {
qualifiers: qual.q,
access,
mq_type,
label,
name,
}))
}
fn parse_userns(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut access = Vec::new();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected userns access"))?;
access.push(t);
}
}
}
Ok(Rule::Userns(UsernsRule {
qualifiers: qual.q,
access,
}))
}
fn parse_io_uring(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut access = Vec::new();
let mut label = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected io_uring token"))?;
if let Some(v) = t.strip_prefix("label=") {
label = Some(FileRulePattern::parse(v)?);
} else {
access.push(t);
}
}
}
}
Ok(Rule::IoUring(IoUringRule {
qualifiers: qual.q,
access,
label,
}))
}
fn parse_signal(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut access = Vec::new();
let mut set = None;
let mut peer = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
Some('(') => self.parse_paren_access(&mut access)?,
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected signal token"))?;
if let Some(v) = t.strip_prefix("set=") {
if v.is_empty() && self.cur.peek() == Some('(') {
set = Some(self.parse_paren_list()?);
} else {
set = Some(split_paren_list(v));
}
} else if let Some(v) = t.strip_prefix("peer=") {
peer = Some(FileRulePattern::parse(v)?);
} else {
access.push(t);
}
}
}
}
Ok(Rule::Signal(SignalRule {
qualifiers: qual.q,
access,
set,
peer,
}))
}
fn parse_paren_access(&mut self, access: &mut Vec<String>) -> Result<(), ParseError> {
self.cur.skip_trivia();
self.expect('(')?;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(')') => {
self.cur.bump();
break;
}
Some(',') => {
self.cur.bump();
}
None => return Err(self.cur.error("unterminated `(...)` access list")),
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected access"))?;
access.push(t);
}
}
}
Ok(())
}
fn parse_paren_list(&mut self) -> Result<Vec<String>, ParseError> {
self.cur.skip_trivia();
self.expect('(')?;
let mut out = Vec::new();
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(')') => {
self.cur.bump();
break;
}
Some(',') => {
self.cur.bump();
}
None => return Err(self.cur.error("unterminated `(...)` list")),
_ => {
let v = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected list value"))?;
out.push(v);
}
}
}
Ok(out)
}
fn parse_ptrace(&mut self, qual: Qual) -> Result<Rule, ParseError> {
let mut access = Vec::new();
let mut peer = None;
loop {
self.cur.skip_trivia();
match self.cur.peek() {
Some(',') | None | Some('}') => break,
Some('(') => self.parse_paren_access(&mut access)?,
_ => {
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected ptrace token"))?;
if let Some(v) = t.strip_prefix("peer=") {
peer = Some(FileRulePattern::parse(v)?);
} else {
access.push(t);
}
}
}
}
Ok(Rule::Ptrace(PtraceRule {
qualifiers: qual.q,
access,
peer,
}))
}
fn parse_file_rule(&mut self, qual: Qual, _file_keyword: bool) -> Result<Rule, ParseError> {
self.cur.skip_trivia();
let start = self.cur.pos();
let t1 = self.cur.read_value()?;
let (path, access) = match t1 {
None => (None, Vec::new()),
Some(t1) if is_access_token(&t1) => {
let access = parse_access(&t1)?;
self.cur.skip_trivia();
match self.cur.read_value()? {
Some(p) => (Some(FileRulePattern::parse(&p)?), access),
None => (None, access),
}
}
Some(t1) => {
let path = FileRulePattern::parse(&t1)?;
self.cur.skip_trivia();
let t2 = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error_at(start, "expected access in file rule"))?;
if !is_access_token(&t2) {
return Err(self.cur.error("expected access list in file rule"));
}
let access = parse_access(&t2)?;
(Some(path), access)
}
};
let mut exec_target = None;
self.cur.skip_trivia();
if self.cur.starts_with("->") {
self.cur.bump();
self.cur.bump();
self.cur.skip_trivia();
let t = self
.cur
.read_value()?
.ok_or_else(|| self.cur.error("expected exec target after `->`"))?;
exec_target = Some(FileRulePattern::parse(&t)?);
}
Ok(Rule::File(FileRule {
qualifiers: qual.q,
owner: qual.owner,
group: qual.group,
path,
access,
exec_target,
}))
}
fn expect(&mut self, c: char) -> Result<(), ParseError> {
if self.cur.consume_if(c) {
Ok(())
} else {
Err(self.cur.error(format!("expected `{c}`")))
}
}
fn expect_comma(&mut self) -> Result<(), ParseError> {
self.cur.skip_trivia();
self.expect(',')
}
fn expect_open_brace(&mut self) -> Result<(), ParseError> {
self.cur.skip_trivia();
self.expect('{')
}
fn expect_arrow(&mut self) -> Result<(), ParseError> {
self.cur.skip_trivia();
if self.cur.starts_with("->") {
self.cur.bump();
self.cur.bump();
Ok(())
} else {
Err(self.cur.error("expected `->`"))
}
}
}
fn split_flag(t: &str) -> Flag {
if let Some((name, value)) = t.split_once('=') {
Flag {
name: name.to_string(),
value: Some(value.to_string()),
}
} else {
Flag {
name: t.to_string(),
value: None,
}
}
}
fn split_paren_list(s: &str) -> Vec<String> {
let inner = s
.strip_prefix('(')
.and_then(|s| s.strip_suffix(')'))
.unwrap_or(s);
inner
.split(',')
.map(|p| p.trim().to_string())
.filter(|p| !p.is_empty())
.collect()
}
fn parse_limit_value(s: &str) -> Result<LimitValue, ParseError> {
let (sign, rest) = if let Some(r) = s.strip_prefix('-') {
(-1i64, r)
} else if let Some(r) = s.strip_prefix('+') {
(1i64, r)
} else {
(1i64, s)
};
let digits_end = rest
.find(|c: char| !c.is_ascii_digit())
.unwrap_or(rest.len());
let (num, unit) = rest.split_at(digits_end);
if num.is_empty() {
return Err(ParseError::detached(format!("invalid rlimit value `{s}`")));
}
let number: i64 = num
.parse()
.map_err(|_| ParseError::detached(format!("invalid rlimit value `{s}`")))?;
let unit = if unit.is_empty() {
None
} else {
Some(unit.to_string())
};
Ok(LimitValue {
number: sign * number,
unit,
})
}
fn classify_network_access(t: &str) -> Option<NetworkAccess> {
Some(match t {
"create" => NetworkAccess::Create,
"bind" => NetworkAccess::Bind,
"listen" => NetworkAccess::Listen,
"accept" => NetworkAccess::Accept,
"connect" => NetworkAccess::Connect,
"shutdown" => NetworkAccess::Shutdown,
"getattr" => NetworkAccess::GetAttr,
"setattr" => NetworkAccess::SetAttr,
"getopt" => NetworkAccess::GetOpt,
"setopt" => NetworkAccess::SetOpt,
"send" => NetworkAccess::Send,
"receive" => NetworkAccess::Receive,
"r" | "read" => NetworkAccess::Read,
"w" | "write" => NetworkAccess::Write,
"rw" => NetworkAccess::ReadWrite,
_ => return None,
})
}
const EXEC_TRANSITIONS: &[&str] = &[
"Pix", "PUx", "CUx", "Cix", "pix", "pux", "cix", "cux", "Ux", "Px", "Cx", "ix", "ux", "px",
"cx", "x",
];
fn parse_access(token: &str) -> Result<Vec<FileAccess>, ParseError> {
let mut out = Vec::new();
let mut rest = token;
while !rest.is_empty() {
let mut matched = false;
for t in EXEC_TRANSITIONS {
if rest.starts_with(t) {
out.push(FileAccess::Exec(exec_transition(t)?));
rest = &rest[t.len()..];
matched = true;
break;
}
}
if matched {
continue;
}
let c = rest.chars().next().unwrap();
let acc = match c {
'r' => FileAccess::Read,
'w' => FileAccess::Write,
'a' => FileAccess::Append,
'l' => FileAccess::Link,
'k' => FileAccess::Lock,
'm' => FileAccess::MemoryMap,
_ => {
return Err(ParseError::detached(format!(
"invalid access character `{c}` in `{token}`"
)));
}
};
out.push(acc);
rest = &rest[c.len_utf8()..];
}
Ok(out)
}
fn exec_transition(t: &str) -> Result<ExecTransition, ParseError> {
Ok(match t {
"ix" => ExecTransition::Inherit,
"ux" => ExecTransition::Unconstrained,
"Ux" => ExecTransition::UnconstrainedSafe,
"px" => ExecTransition::Profile,
"Px" => ExecTransition::ProfileSafe,
"cx" => ExecTransition::Child,
"Cx" => ExecTransition::ChildSafe,
"pix" => ExecTransition::ProfileInherit,
"Pix" => ExecTransition::ProfileInheritSafe,
"cix" => ExecTransition::ChildInherit,
"Cix" => ExecTransition::ChildInheritSafe,
"pux" => ExecTransition::ProfileUnconstrained,
"PUx" => ExecTransition::ProfileUnconstrainedSafe,
"cux" => ExecTransition::ChildUnconstrained,
"CUx" => ExecTransition::ChildUnconstrainedSafe,
"x" => ExecTransition::BareX,
_ => {
return Err(ParseError::detached(format!(
"unknown exec transition `{t}`"
)));
}
})
}
fn is_access_token(token: &str) -> bool {
parse_access(token).is_ok() && !token.is_empty()
}