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

use std::{
    ffi::{CString, OsStr},
    os::unix::ffi::OsStrExt,
    path::Path,
};

use serde::{Deserialize, Serialize};
use zbus::zvariant::Type;

/// A file name represented as a nul-terminated byte array.
#[derive(Type, Debug, Default, PartialEq)]
#[zvariant(signature = "ay")]
pub struct FilePath(CString);

impl AsRef<Path> for FilePath {
    fn as_ref(&self) -> &Path {
        OsStr::from_bytes(self.0.as_bytes()).as_ref()
    }
}

impl FilePath {
    pub(crate) fn new<T: AsRef<Path>>(s: T) -> Result<Self, crate::Error> {
        let c_string = CString::new(s.as_ref().as_os_str().as_bytes())
            .map_err(|err| crate::Error::NulTerminated(err.nul_position()))?;

        Ok(Self(c_string))
    }
}

impl Serialize for FilePath {
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
    where
        S: serde::Serializer,
    {
        serializer.serialize_bytes(self.0.as_bytes_with_nul())
    }
}

impl<'de> Deserialize<'de> for FilePath {
    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
    where
        D: serde::Deserializer<'de>,
    {
        let bytes = <Vec<u8>>::deserialize(deserializer)?;
        let c_string = CString::from_vec_with_nul(bytes)
            .map_err(|_| serde::de::Error::custom("Bytes are not nul-terminated"))?;

        Ok(Self(c_string))
    }
}

#[cfg(test)]
mod tests {
    use zbus::zvariant::{
        serialized::{Context, Data},
        to_bytes, Endian,
    };

    use super::*;

    #[test]
    fn test_serialize_is_nul_terminated() {
        let bytes = vec![97, 98, 99, 0]; // b"abc\0"

        assert_eq!(b"abc\0", bytes.as_slice());

        let c_string = CString::from_vec_with_nul(bytes.clone()).unwrap();

        assert_eq!(c_string.as_bytes_with_nul(), &bytes);

        let ctxt = Context::new_dbus(Endian::Little, 0);
        let file_path = FilePath(c_string);

        let file_path_2 = FilePath::new("abc").unwrap();

        let encoded_filename = to_bytes(ctxt, &file_path).unwrap().to_vec();
        let encoded_filename_2 = to_bytes(ctxt, &file_path_2).unwrap().to_vec();
        let encoded_bytes = to_bytes(ctxt, &bytes).unwrap().to_vec();

        // It does not matter whether we use new("abc") or deserialize from b"abc\0".
        assert_eq!(encoded_filename, encoded_bytes);
        assert_eq!(encoded_filename_2, encoded_bytes);

        let decoded: FilePath = Data::new(encoded_bytes, ctxt).deserialize().unwrap().0;
        assert_eq!(decoded, file_path);
        assert_eq!(decoded, file_path_2);
    }
}