zbus/message/
fields.rs

Help
1use serde::{Deserialize, Serialize};
2use static_assertions::assert_impl_all;
3use std::num::NonZeroU32;
4use zbus_names::{BusName, ErrorName, InterfaceName, MemberName, UniqueName};
5use zvariant::{ObjectPath, Signature, Type};
6
7use crate::{
8    message::{Field, FieldCode, Header, Message},
9    Result,
10};
11
12// It's actually 10 (and even not that) but let's round it to next 8-byte alignment
13const MAX_FIELDS_IN_MESSAGE: usize = 16;
14
15/// A collection of [`Field`] instances.
16///
17/// [`Field`]: enum.Field.html
18#[derive(Debug, Clone, Serialize, Deserialize, Type)]
19pub(crate) struct Fields<'m>(#[serde(borrow)] Vec<Field<'m>>);
20
21assert_impl_all!(Fields<'_>: Send, Sync, Unpin);
22
23impl<'m> Fields<'m> {
24    /// Creates an empty collection of fields.
25    pub fn new() -> Self {
26        Self::default()
27    }
28
29    /// Appends a [`Field`] to the collection of fields in the message.
30    ///
31    /// [`Field`]: enum.Field.html
32    pub fn add<'f: 'm>(&mut self, field: Field<'f>) {
33        self.0.push(field);
34    }
35
36    /// Replaces a [`Field`] from the collection of fields with one with the same code,
37    /// returning the old value if present.
38    ///
39    /// [`Field`]: enum.Field.html
40    pub fn replace<'f: 'm>(&mut self, field: Field<'f>) -> Option<Field<'m>> {
41        let code = field.code();
42        if let Some(found) = self.0.iter_mut().find(|f| f.code() == code) {
43            return Some(std::mem::replace(found, field));
44        }
45        self.add(field);
46        None
47    }
48
49    /// Returns a slice with all the [`Field`] in the message.
50    ///
51    /// [`Field`]: enum.Field.html
52    pub fn get(&self) -> &[Field<'m>] {
53        &self.0
54    }
55
56    /// Gets a reference to a specific [`Field`] by its code.
57    ///
58    /// Returns `None` if the message has no such field.
59    ///
60    /// [`Field`]: enum.Field.html
61    pub fn get_field(&self, code: FieldCode) -> Option<&Field<'m>> {
62        self.0.iter().find(|f| f.code() == code)
63    }
64
65    /// Remove the field matching the `code`.
66    ///
67    /// Returns `true` if a field was found and removed, `false` otherwise.
68    pub(crate) fn remove(&mut self, code: FieldCode) -> bool {
69        match self.0.iter().enumerate().find(|(_, f)| f.code() == code) {
70            Some((i, _)) => {
71                self.0.remove(i);
72
73                true
74            }
75            None => false,
76        }
77    }
78}
79
80/// A byte range of a field in a Message, used in [`QuickFields`].
81///
82/// Some invalid encodings (end = 0) are used to indicate "not cached" and "not present".
83#[derive(Debug, Default, Clone, Copy)]
84pub(crate) struct FieldPos {
85    start: u32,
86    end: u32,
87}
88
89impl FieldPos {
90    pub fn new_not_present() -> Self {
91        Self { start: 1, end: 0 }
92    }
93
94    pub fn build(msg_buf: &[u8], field_buf: &str) -> Option<Self> {
95        let buf_start = msg_buf.as_ptr() as usize;
96        let field_start = field_buf.as_ptr() as usize;
97        let offset = field_start.checked_sub(buf_start)?;
98        if offset <= msg_buf.len() && offset + field_buf.len() <= msg_buf.len() {
99            Some(Self {
100                start: offset.try_into().ok()?,
101                end: (offset + field_buf.len()).try_into().ok()?,
102            })
103        } else {
104            None
105        }
106    }
107
108    pub fn new<T>(msg_buf: &[u8], field: Option<&T>) -> Self
109    where
110        T: std::ops::Deref<Target = str>,
111    {
112        field
113            .and_then(|f| Self::build(msg_buf, f.deref()))
114            .unwrap_or_else(Self::new_not_present)
115    }
116
117    /// Reassemble a previously cached field.
118    ///
119    /// **NOTE**: The caller must ensure that the `msg_buff` is the same one `build` was called for.
120    /// Otherwise, you'll get a panic.
121    pub fn read<'m, T>(&self, msg_buf: &'m [u8]) -> Option<T>
122    where
123        T: TryFrom<&'m str>,
124        T::Error: std::fmt::Debug,
125    {
126        match self {
127            Self {
128                start: 0..=1,
129                end: 0,
130            } => None,
131            Self { start, end } => {
132                let s = std::str::from_utf8(&msg_buf[(*start as usize)..(*end as usize)])
133                    .expect("Invalid utf8 when reconstructing string");
134                // We already check the fields during the construction of `Self`.
135                T::try_from(s)
136                    .map(Some)
137                    .expect("Invalid field reconstruction")
138            }
139        }
140    }
141}
142
143/// A cache of the Message header fields.
144#[derive(Debug, Default, Copy, Clone)]
145pub(crate) struct QuickFields {
146    path: FieldPos,
147    interface: FieldPos,
148    member: FieldPos,
149    error_name: FieldPos,
150    reply_serial: Option<NonZeroU32>,
151    destination: FieldPos,
152    sender: FieldPos,
153    signature: FieldPos,
154    unix_fds: Option<u32>,
155}
156
157impl QuickFields {
158    pub fn new(buf: &[u8], header: &Header<'_>) -> Result<Self> {
159        Ok(Self {
160            path: FieldPos::new(buf, header.path()),
161            interface: FieldPos::new(buf, header.interface()),
162            member: FieldPos::new(buf, header.member()),
163            error_name: FieldPos::new(buf, header.error_name()),
164            reply_serial: header.reply_serial(),
165            destination: FieldPos::new(buf, header.destination()),
166            sender: FieldPos::new(buf, header.sender()),
167            signature: FieldPos::new(buf, header.signature()),
168            unix_fds: header.unix_fds(),
169        })
170    }
171
172    pub fn path<'m>(&self, msg: &'m Message) -> Option<ObjectPath<'m>> {
173        self.path.read(msg.data())
174    }
175
176    pub fn interface<'m>(&self, msg: &'m Message) -> Option<InterfaceName<'m>> {
177        self.interface.read(msg.data())
178    }
179
180    pub fn member<'m>(&self, msg: &'m Message) -> Option<MemberName<'m>> {
181        self.member.read(msg.data())
182    }
183
184    pub fn error_name<'m>(&self, msg: &'m Message) -> Option<ErrorName<'m>> {
185        self.error_name.read(msg.data())
186    }
187
188    pub fn reply_serial(&self) -> Option<NonZeroU32> {
189        self.reply_serial
190    }
191
192    pub fn destination<'m>(&self, msg: &'m Message) -> Option<BusName<'m>> {
193        self.destination.read(msg.data())
194    }
195
196    pub fn sender<'m>(&self, msg: &'m Message) -> Option<UniqueName<'m>> {
197        self.sender.read(msg.data())
198    }
199
200    pub fn signature<'m>(&self, msg: &'m Message) -> Option<Signature<'m>> {
201        self.signature.read(msg.data())
202    }
203
204    pub fn unix_fds(&self) -> Option<u32> {
205        self.unix_fds
206    }
207}
208
209impl<'m> Default for Fields<'m> {
210    fn default() -> Self {
211        Self(Vec::with_capacity(MAX_FIELDS_IN_MESSAGE))
212    }
213}
214
215impl<'m> std::ops::Deref for Fields<'m> {
216    type Target = [Field<'m>];
217
218    fn deref(&self) -> &Self::Target {
219        self.get()
220    }
221}
222
223#[cfg(test)]
224mod tests {
225    use super::{Field, Fields};
226
227    #[test]
228    fn test() {
229        let mut mf = Fields::new();
230        assert_eq!(mf.len(), 0);
231        mf.add(Field::ReplySerial(42.try_into().unwrap()));
232        assert_eq!(mf.len(), 1);
233        mf.add(Field::ReplySerial(43.try_into().unwrap()));
234        assert_eq!(mf.len(), 2);
235
236        let mut mf = Fields::new();
237        assert_eq!(mf.len(), 0);
238        mf.replace(Field::ReplySerial(42.try_into().unwrap()));
239        assert_eq!(mf.len(), 1);
240        mf.replace(Field::ReplySerial(43.try_into().unwrap()));
241        assert_eq!(mf.len(), 1);
242    }
243}
zbus/message/fields.rs

zbus/message/
fields.rs
