linux_audit_parser/
value.rs

1use std::convert::{Into, TryFrom};
2use std::fmt::{self, Debug, Display};
3use std::iter::Iterator;
4use std::str::{self, FromStr};
5use std::string::*;
6
7#[cfg(feature = "serde")]
8use serde::{
9    de::{self, MapAccess, SeqAccess, Visitor},
10    ser::SerializeMap,
11    Deserialize, Deserializer, Serialize, Serializer,
12};
13
14use crate::*;
15
16/// Quotes types in [`Value`] strings
17#[derive(Debug, PartialEq, Eq, Clone, Copy)]
18pub enum Quote {
19    None,
20    Single,
21    Double,
22    Braces,
23}
24
25#[derive(Clone, PartialEq)]
26/// [`Value`]s parsed as hexadecimal, decimal, or octal numbers
27pub enum Number {
28    Hex(u64),
29    Dec(i64),
30    Oct(u64),
31}
32
33impl Debug for Number {
34    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
35        write!(f, "Num:<{self}>")
36    }
37}
38
39impl Display for Number {
40    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
41        match self {
42            Number::Hex(n) => write!(f, "0x{n:x}"),
43            Number::Oct(n) => write!(f, "0o{n:o}"),
44            Number::Dec(n) => write!(f, "{n}"),
45        }
46    }
47}
48
49impl FromStr for Number {
50    type Err = std::num::ParseIntError;
51    fn from_str(s: &str) -> Result<Self, Self::Err> {
52        if let Some(s) = s.strip_prefix("0x") {
53            Ok(Number::Hex(u64::from_str_radix(s, 16)?))
54        } else if let Some(s) = s.strip_prefix("0o") {
55            Ok(Number::Oct(u64::from_str_radix(s, 8)?))
56        } else {
57            Ok(Number::Dec(i64::from_str(s)?))
58        }
59    }
60}
61
62#[cfg(feature = "serde")]
63impl Serialize for Number {
64    #[inline(always)]
65    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
66        match self {
67            Number::Dec(n) => s.serialize_i64(*n),
68            _ => s.collect_str(&self),
69        }
70    }
71}
72
73#[cfg(feature = "serde")]
74impl<'de> Deserialize<'de> for Number {
75    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
76        d.deserialize_any(NumberVisitor)
77    }
78}
79
80#[cfg(feature = "serde")]
81struct NumberVisitor;
82
83#[cfg(feature = "serde")]
84impl Visitor<'_> for NumberVisitor {
85    type Value = Number;
86
87    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
88        formatter.write_str("a string or an integer")
89    }
90
91    fn visit_i64<E: de::Error>(self, value: i64) -> Result<Self::Value, E> {
92        Ok(Number::Dec(value))
93    }
94
95    fn visit_u64<E: de::Error>(self, value: u64) -> Result<Self::Value, E> {
96        Ok(Number::Dec(value as _))
97    }
98
99    fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
100        Number::from_str(value).map_err(E::custom)
101    }
102}
103
104/// Representation of the value part of key/value pairs in [`Body`]
105#[derive(Clone, PartialEq)]
106pub enum Value<'a> {
107    /// Empty value.
108    Empty,
109    /// A byte string.
110    Str(&'a [u8], Quote),
111    /// Parsed number.
112    Number(Number),
113    /// A list of byte strings.
114    List(Vec<Value<'a>>),
115    /// A byte string that is not stored within the [`Body`]. Used for
116    /// decoded hex-strings.
117    Owned(Vec<u8>),
118    /// An internal key/value map. Used when [`Parser::split_msg`] is set.
119    Map(Vec<(Key, Value<'a>)>),
120    /// Non-contiguous byte string. Not produced by the parser.
121    Segments(Vec<&'a [u8]>),
122    StringifiedList(Vec<Value<'a>>),
123    /// Elements removed from ARGV lists. Not produced by the parser.
124    Skipped((usize, usize)),
125    /// A literal string. Not produced by the parser.
126    Literal(&'static str),
127}
128
129impl Default for Value<'_> {
130    fn default() -> Self {
131        Self::Empty
132    }
133}
134
135impl Value<'_> {
136    pub fn str_len(&self) -> usize {
137        match self {
138            Value::Str(r, _) => r.len(),
139            Value::Segments(vr) => vr.iter().map(|r| r.len()).sum(),
140            _ => 0,
141        }
142    }
143}
144
145impl TryFrom<Value<'_>> for Vec<u8> {
146    type Error = &'static str;
147    fn try_from(v: Value) -> Result<Self, Self::Error> {
148        match v {
149            Value::Str(r, Quote::Braces) => {
150                let mut s = Vec::with_capacity(r.len() + 2);
151                s.push(b'{');
152                s.extend(Vec::from(r));
153                s.push(b'}');
154                Ok(s)
155            }
156            Value::Str(r, _) => Ok(Vec::from(r)),
157            Value::Empty => Ok("".into()),
158            Value::Segments(ranges) => {
159                let l = ranges.iter().map(|r| r.len()).sum();
160                let mut sb = Vec::with_capacity(l);
161                for r in ranges {
162                    sb.extend(Vec::from(r));
163                }
164                Ok(sb)
165            }
166            Value::Number(_) => Err("Won't convert number to string"),
167            Value::List(_) | Value::StringifiedList(_) => Err("Can't convert list to scalar"),
168            Value::Map(_) => Err("Can't convert map to scalar"),
169            Value::Skipped(_) => Err("Can't convert skipped to scalar"),
170            Value::Literal(s) => Ok(s.to_string().into()),
171            Value::Owned(v) => Ok(v),
172        }
173    }
174}
175
176impl TryFrom<Value<'_>> for Vec<Vec<u8>> {
177    type Error = &'static str;
178    fn try_from(value: Value) -> Result<Self, Self::Error> {
179        match value {
180            Value::List(values) | Value::StringifiedList(values) => {
181                let mut rv = Vec::with_capacity(values.len());
182                for v in values {
183                    let s = Vec::try_from(v)?;
184                    rv.push(s);
185                }
186                Ok(rv)
187            }
188            _ => Err("not a list"),
189        }
190    }
191}
192
193impl Debug for Value<'_> {
194    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
195        match self {
196            Value::Str(r, _q) => write!(f, "Str:<{}>", &String::from_utf8_lossy(r)),
197            Value::Empty => write!(f, "Empty"),
198            Value::Segments(segs) => {
199                write!(f, "Segments<")?;
200                for (n, r) in segs.iter().enumerate() {
201                    if n > 0 {
202                        write!(f, ", ")?;
203                    }
204                    write!(f, "{}", String::from_utf8_lossy(r))?;
205                }
206                write!(f, ">")
207            }
208            Value::List(vs) => {
209                write!(f, "List:<")?;
210                for (n, v) in vs.iter().enumerate() {
211                    if n > 0 {
212                        write!(f, ", ")?;
213                    }
214                    match v {
215                        Value::Str(r, _) => {
216                            write!(f, "{}", String::from_utf8_lossy(r))?;
217                        }
218                        Value::Segments(rs) => {
219                            for r in rs {
220                                write!(f, "{}", String::from_utf8_lossy(r))?;
221                            }
222                        }
223                        Value::Number(n) => write!(f, "{n:?}")?,
224                        Value::Skipped((elems, bytes)) => {
225                            write!(f, "Skip<elems{elems} bytes={bytes}>")?;
226                        }
227                        Value::Empty => panic!("list can't contain empty value"),
228                        Value::List(_) | Value::StringifiedList(_) => {
229                            panic!("list can't contain list")
230                        }
231                        Value::Map(_) => panic!("list can't contain map"),
232                        Value::Literal(v) => write!(f, "{v:?}")?,
233                        Value::Owned(v) => write!(f, "{}", String::from_utf8_lossy(v))?,
234                    }
235                }
236                write!(f, ">")
237            }
238            Value::StringifiedList(vs) => {
239                write!(f, "StringifiedList:<")?;
240                for (n, v) in vs.iter().enumerate() {
241                    if n > 0 {
242                        write!(f, " ")?;
243                    }
244                    match v {
245                        Value::Str(r, _) => {
246                            write!(f, "{}", String::from_utf8_lossy(r))?;
247                        }
248                        Value::Segments(rs) => {
249                            for r in rs {
250                                write!(f, "{}", String::from_utf8_lossy(r))?;
251                            }
252                        }
253                        Value::Number(n) => write!(f, "{n:?}")?,
254                        Value::Skipped((elems, bytes)) => {
255                            write!(f, "Skip<elems={elems} bytes={bytes}>")?;
256                        }
257                        Value::Empty => panic!("list can't contain empty value"),
258                        Value::List(_) | Value::StringifiedList(_) => {
259                            panic!("list can't contain list")
260                        }
261                        Value::Map(_) => panic!("List can't contain mapr"),
262                        Value::Literal(v) => write!(f, "{v}")?,
263                        Value::Owned(v) => write!(f, "{}", String::from_utf8_lossy(v))?,
264                    }
265                }
266                write!(f, ">")
267            }
268            Value::Map(vs) => {
269                write!(f, "Map:<")?;
270                for (n, (k, v)) in vs.iter().enumerate() {
271                    if n > 0 {
272                        write!(f, " ")?;
273                    }
274                    write!(f, "{k:?}={v:?}")?;
275                }
276                write!(f, ">")
277            }
278            Value::Number(n) => write!(f, "{n:?}"),
279            Value::Skipped((elems, bytes)) => write!(f, "Skip<elems={elems} bytes={bytes}>"),
280            Value::Literal(s) => write!(f, "{s:?}"),
281            Value::Owned(v) => write!(f, "{}", String::from_utf8_lossy(v)),
282        }
283    }
284}
285
286#[cfg(feature = "serde")]
287impl Serialize for Value<'_> {
288    #[inline(always)]
289    fn serialize<S: Serializer>(&self, s: S) -> Result<S::Ok, S::Error> {
290        match self {
291            Value::Empty => s.serialize_unit(),
292            Value::Str(r, Quote::Braces) => {
293                let mut buf = Vec::with_capacity(r.len() + 2);
294                buf.push(b'{');
295                buf.extend(*r);
296                buf.push(b'}');
297                s.serialize_bytes(&buf)
298            }
299            Value::Str(r, _) => s.serialize_bytes(r),
300            Value::Segments(segs) => {
301                let l = segs.iter().map(|r| r.len()).sum();
302                let mut buf = Vec::with_capacity(l);
303                for seg in segs {
304                    buf.extend(*seg);
305                }
306                s.serialize_bytes(&buf)
307            }
308            Value::List(vs) => s.collect_seq(vs.iter()),
309            Value::StringifiedList(vs) => {
310                let mut buf: Vec<u8> = Vec::with_capacity(vs.len());
311                let mut first = true;
312                for v in vs {
313                    if first {
314                        first = false;
315                    } else {
316                        buf.push(b' ');
317                    }
318                    if let Value::Skipped((args, bytes)) = v {
319                        buf.extend(format!("<<< Skipped: args={args}, bytes={bytes} >>>").bytes());
320                    } else {
321                        buf.extend(v.clone().try_into().unwrap_or_else(|_| vec![b'x']));
322                    }
323                }
324                s.serialize_bytes(&buf)
325            }
326            Value::Number(n) => n.serialize(s),
327            Value::Map(vs) => s.collect_map(vs.iter().cloned()),
328            Value::Skipped((args, bytes)) => {
329                let mut map = s.serialize_map(Some(2))?;
330                map.serialize_entry("skipped_args", args)?;
331                map.serialize_entry("skipped_bytes", bytes)?;
332                map.end()
333            }
334            Value::Literal(v) => s.collect_str(v),
335            Value::Owned(v) => s.serialize_bytes(v),
336        }
337    }
338}
339
340#[cfg(feature = "serde")]
341struct ValueVisitor;
342
343#[cfg(feature = "serde")]
344impl<'de> Visitor<'de> for ValueVisitor {
345    type Value = Value<'de>;
346
347    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
348        formatter.write_str("a string, integer, sequence, map, or null value")
349    }
350
351    fn visit_none<E: de::Error>(self) -> Result<Self::Value, E> {
352        Ok(Value::Empty)
353    }
354
355    fn visit_unit<E: de::Error>(self) -> Result<Self::Value, E> {
356        Ok(Value::Empty)
357    }
358
359    fn visit_i64<E: de::Error>(self, value: i64) -> Result<Self::Value, E> {
360        Ok(Value::Number(Number::Dec(value)))
361    }
362
363    fn visit_u64<E: de::Error>(self, value: u64) -> Result<Self::Value, E> {
364        Ok(Value::Number(Number::Dec(value as _)))
365    }
366
367    fn visit_str<E: de::Error>(self, value: &str) -> Result<Self::Value, E> {
368        if let Ok(n) = Number::from_str(value) {
369            Ok(Value::Number(n))
370        } else {
371            Ok(Value::from(value.to_string()))
372        }
373    }
374
375    fn visit_bytes<E: de::Error>(self, value: &[u8]) -> Result<Self::Value, E> {
376        Ok(Value::from(value.to_vec()))
377    }
378
379    fn visit_seq<A: SeqAccess<'de>>(self, mut seq: A) -> Result<Self::Value, A::Error> {
380        let mut v = vec![];
381        while let Some(elem) = seq.next_element()? {
382            v.push(elem);
383        }
384        Ok(Value::List(v))
385    }
386
387    fn visit_map<A: MapAccess<'de>>(self, mut map: A) -> Result<Self::Value, A::Error> {
388        let mut kv = vec![];
389        while let Some((k, v)) = map.next_entry::<Key, Value>()? {
390            kv.push((k, v));
391        }
392        Ok(Value::Map(kv))
393    }
394}
395
396#[cfg(feature = "serde")]
397impl<'de> Deserialize<'de> for Value<'de> {
398    #[inline(always)]
399    fn deserialize<D: Deserializer<'de>>(d: D) -> Result<Self, D::Error> {
400        d.deserialize_any(ValueVisitor)
401    }
402}
403
404impl PartialEq<str> for Value<'_> {
405    fn eq(&self, other: &str) -> bool {
406        self == other.as_bytes()
407    }
408}
409
410impl PartialEq<[u8]> for Value<'_> {
411    fn eq(&self, other: &[u8]) -> bool {
412        match self {
413            Value::Empty => other.is_empty(),
414            Value::Str(r, _) => r == &other,
415            Value::Segments(segs) => {
416                let l = segs.iter().map(|s| s.len()).sum();
417                let mut buf: Vec<u8> = Vec::with_capacity(l);
418                for s in segs {
419                    buf.extend(*s);
420                }
421                buf == other
422            }
423            Value::Literal(s) => s.as_bytes() == other,
424            Value::Owned(v) => v == other,
425            Value::List(_)
426            | Value::StringifiedList(_)
427            | Value::Map(_)
428            | Value::Skipped(_)
429            | Value::Number(_) => false,
430        }
431    }
432}
433
434impl<'a> From<&'a [u8]> for Value<'a> {
435    fn from(value: &'a [u8]) -> Self {
436        Value::Str(value, Quote::None)
437    }
438}
439
440impl<'a> From<&'a str> for Value<'a> {
441    fn from(value: &'a str) -> Self {
442        Self::from(value.as_bytes())
443    }
444}
445
446impl From<Vec<u8>> for Value<'_> {
447    fn from(value: Vec<u8>) -> Self {
448        Value::Owned(value)
449    }
450}
451
452impl From<String> for Value<'_> {
453    fn from(value: String) -> Self {
454        Self::from(Vec::from(value))
455    }
456}
457
458impl From<i64> for Value<'_> {
459    fn from(value: i64) -> Self {
460        Value::Number(Number::Dec(value))
461    }
462}
linux_audit_parser/value.rs

linux_audit_parser/
value.rs
