zigbee_primitives/
wire.rs1use crate::{ExtPanId, Ieee, Key};
7
8#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
10#[error("frame truncated: needed {needed} more bytes at offset {offset}")]
11pub struct Truncated {
12 pub offset: usize,
14 pub needed: usize,
16}
17
18#[derive(Debug, Clone)]
20pub struct Reader<'a> {
21 buf: &'a [u8],
22 pos: usize,
23}
24
25impl<'a> Reader<'a> {
26 pub fn new(buf: &'a [u8]) -> Self {
28 Reader { buf, pos: 0 }
29 }
30
31 pub fn remaining(&self) -> usize {
33 self.buf.len().saturating_sub(self.pos)
34 }
35
36 pub fn is_empty(&self) -> bool {
38 self.remaining() == 0
39 }
40
41 pub fn position(&self) -> usize {
43 self.pos
44 }
45
46 pub fn bytes(&mut self, n: usize) -> Result<&'a [u8], Truncated> {
48 let end = self.pos.checked_add(n).filter(|end| *end <= self.buf.len());
49 match end.and_then(|end| self.buf.get(self.pos..end)) {
50 Some(slice) => {
51 self.pos += n;
52 Ok(slice)
53 }
54 None => Err(Truncated {
55 offset: self.pos,
56 needed: n.saturating_sub(self.remaining()),
57 }),
58 }
59 }
60
61 pub fn rest(&mut self) -> &'a [u8] {
63 let rest = self.buf.get(self.pos..).unwrap_or(&[]);
64 self.pos = self.buf.len();
65 rest
66 }
67
68 pub fn array<const N: usize>(&mut self) -> Result<[u8; N], Truncated> {
70 let mut out = [0u8; N];
71 out.copy_from_slice(self.bytes(N)?);
72 Ok(out)
73 }
74
75 pub fn u8(&mut self) -> Result<u8, Truncated> {
77 Ok(self.array::<1>()?[0])
78 }
79
80 pub fn i8(&mut self) -> Result<i8, Truncated> {
82 Ok(self.u8()? as i8)
83 }
84
85 pub fn u16(&mut self) -> Result<u16, Truncated> {
87 Ok(u16::from_le_bytes(self.array()?))
88 }
89
90 pub fn u32(&mut self) -> Result<u32, Truncated> {
92 Ok(u32::from_le_bytes(self.array()?))
93 }
94
95 pub fn u64(&mut self) -> Result<u64, Truncated> {
97 Ok(u64::from_le_bytes(self.array()?))
98 }
99
100 pub fn uint_n(&mut self, width: usize) -> Result<u64, Truncated> {
102 let bytes = self.bytes(width.min(8))?;
103 Ok(bytes
104 .iter()
105 .rev()
106 .fold(0u64, |acc, b| (acc << 8) | u64::from(*b)))
107 }
108
109 pub fn bool(&mut self) -> Result<bool, Truncated> {
111 Ok(self.u8()? != 0)
112 }
113
114 pub fn ieee(&mut self) -> Result<Ieee, Truncated> {
116 Ok(Ieee::from_le_bytes(self.array()?))
117 }
118
119 pub fn ext_pan_id(&mut self) -> Result<ExtPanId, Truncated> {
121 Ok(ExtPanId::from_le_bytes(self.array()?))
122 }
123
124 pub fn key(&mut self) -> Result<Key, Truncated> {
126 Ok(Key(self.array()?))
127 }
128
129 pub fn u8_prefixed(&mut self) -> Result<&'a [u8], Truncated> {
131 let len = self.u8()?;
132 self.bytes(usize::from(len))
133 }
134
135 pub fn u16_list(&mut self, count: usize) -> Result<Vec<u16>, Truncated> {
137 let raw = self.bytes(count.saturating_mul(2))?;
139 Ok(raw
140 .as_chunks::<2>()
141 .0
142 .iter()
143 .map(|c| u16::from_le_bytes(*c))
144 .collect())
145 }
146}
147
148pub trait Writer {
150 fn put_u8(&mut self, v: u8);
152 fn put_u16(&mut self, v: u16);
154 fn put_u32(&mut self, v: u32);
156 fn put_u64(&mut self, v: u64);
158 fn put_uint_n(&mut self, v: u64, width: usize);
160 fn put_bytes(&mut self, v: &[u8]);
162 fn put_ieee(&mut self, v: Ieee);
164 fn put_ext_pan_id(&mut self, v: ExtPanId);
166 fn put_key(&mut self, v: &Key);
168 fn put_u8_prefixed(&mut self, v: &[u8]);
170}
171
172impl Writer for Vec<u8> {
173 fn put_u8(&mut self, v: u8) {
174 self.push(v);
175 }
176 fn put_u16(&mut self, v: u16) {
177 self.extend_from_slice(&v.to_le_bytes());
178 }
179 fn put_u32(&mut self, v: u32) {
180 self.extend_from_slice(&v.to_le_bytes());
181 }
182 fn put_u64(&mut self, v: u64) {
183 self.extend_from_slice(&v.to_le_bytes());
184 }
185 fn put_uint_n(&mut self, v: u64, width: usize) {
186 let bytes = v.to_le_bytes();
187 self.extend_from_slice(bytes.get(..width.min(8)).unwrap_or(&bytes));
188 }
189 fn put_bytes(&mut self, v: &[u8]) {
190 self.extend_from_slice(v);
191 }
192 fn put_ieee(&mut self, v: Ieee) {
193 self.extend_from_slice(&v.to_le_bytes());
194 }
195 fn put_ext_pan_id(&mut self, v: ExtPanId) {
196 self.extend_from_slice(&v.to_le_bytes());
197 }
198 fn put_key(&mut self, v: &Key) {
199 self.extend_from_slice(&v.0);
200 }
201 fn put_u8_prefixed(&mut self, v: &[u8]) {
202 let v = v.get(..v.len().min(255)).unwrap_or(v);
203 self.push(v.len() as u8);
204 self.extend_from_slice(v);
205 }
206}
207
208#[cfg(test)]
209mod tests {
210 use super::*;
211
212 #[test]
213 fn reads_and_reports_truncation() {
214 let mut r = Reader::new(&[1, 2, 3, 4, 5]);
215 assert_eq!(r.u16().unwrap(), 0x0201);
216 assert_eq!(r.uint_n(3).unwrap(), 0x050403);
217 assert_eq!(
218 r.u8(),
219 Err(Truncated {
220 offset: 5,
221 needed: 1
222 })
223 );
224 let mut r = Reader::new(&[3, 1]);
225 assert!(r.u8_prefixed().is_err());
226 let mut r = Reader::new(&[]);
227 assert!(r.u16_list(usize::MAX).is_err());
228 }
229
230 #[test]
231 fn writes_little_endian() {
232 let mut w = Vec::new();
233 w.put_u16(0x1234);
234 w.put_uint_n(0xAABBCC, 3);
235 w.put_u8_prefixed(b"hi");
236 assert_eq!(w, [0x34, 0x12, 0xCC, 0xBB, 0xAA, 2, b'h', b'i']);
237 }
238}