rootasrole 4.1.0

A better alternative to sudo(-rs)/su
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124

use std::{borrow::Cow, str::FromStr};

use log::debug;
use rootasrole_core::database::structs::SetBehavior;
use serde::Deserialize;

use crate::finder::de::{DCommand, DCommandList};

impl<'de: 'a, 'a> Deserialize<'de> for DCommandList<'a> {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        #[derive(Deserialize)]
        #[serde(field_identifier, rename_all = "lowercase")]
        #[repr(u8)]
        enum Field {
            #[serde(alias = "d", alias = "default_behavior")]
            Default,
            #[serde(alias = "a")]
            Add,
            #[serde(alias = "s", alias = "sub", alias = "del")]
            Del,
        }
        #[derive(Default)]
        struct DCommandListVisitor<'a> {
            _phantom: std::marker::PhantomData<&'a ()>,
        }
        impl<'de: 'a, 'a> serde::de::Visitor<'de> for DCommandListVisitor<'a> {
            type Value = DCommandList<'a>;

            fn expecting(&self, formatter: &mut std::fmt::Formatter) -> std::fmt::Result {
                formatter.write_str("CommandList structure")
            }

            fn visit_map<V>(self, mut map: V) -> Result<Self::Value, V::Error>
            where
                V: serde::de::MapAccess<'de>,
            {
                let mut default_behavior = None;
                let mut add: Cow<'_, [DCommand<'_>]> = Cow::Borrowed(&[]);
                let mut del: Cow<'_, [DCommand<'_>]> = Cow::Borrowed(&[]);
                while let Some(key) = map.next_key()? {
                    match key {
                        Field::Default => {
                            debug!("DCommandListVisitor: default");
                            default_behavior = Some(map.next_value()?);
                        }
                        Field::Add => {
                            debug!("DCommandListVisitor: add");
                            add = map.next_value()?;
                        }
                        Field::Del => {
                            debug!("DCommandListVisitor: del");
                            del = map.next_value()?;
                        }
                    }
                }
                Ok(DCommandList {
                    default_behavior,
                    add,
                    del,
                })
            }

            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
            where
                A: serde::de::SeqAccess<'de>,
            {
                let mut add = Vec::new();
                while let Some(command) = seq.next_element()? {
                    add.push(command);
                }
                Ok(DCommandList {
                    default_behavior: None,
                    add: Cow::Owned(add),
                    del: Cow::Borrowed(&[]),
                })
            }
            fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                self.visit_str(&v)
            }
            fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                let set = SetBehavior::from_str(v).map_err(serde::de::Error::custom)?;
                Ok(DCommandList {
                    default_behavior: Some(set),
                    add: Cow::Borrowed(&[]),
                    del: Cow::Borrowed(&[]),
                })
            }
            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<Self::Value, E>
            where
                E: serde::de::Error,
            {
                self.visit_str(v)
            }
        }
        deserializer.deserialize_any(DCommandListVisitor::default())
    }
}

#[cfg(test)]
mod test {
    use crate::finder::de::{DCommand, DCommandList};

    #[test]
    fn test_dcommandlist_deserialize() {
        let list: DCommandList = serde_json::from_str(
            r#"{"default": "none", "add": ["/usr/bin/ls"], "del": ["/usr/bin/rm"]}"#,
        )
        .unwrap();
        assert_eq!(list.add.as_ref(), [DCommand::simple("/usr/bin/ls")]);
        assert_eq!(list.del.as_ref(), [DCommand::simple("/usr/bin/rm")]);
        let list: DCommandList = serde_json::from_str(r#"["/usr/bin/ls"]"#).unwrap();
        assert_eq!(list.add.as_ref(), [DCommand::simple("/usr/bin/ls")]);
        assert!(serde_json::from_str::<DCommandList>("1").is_err());
    }
}