tls_codec/
primitives.rs

1//! Codec implementations for unsigned integer primitives.
2
3use alloc::{boxed::Box, vec::Vec};
4
5use crate::{DeserializeBytes, SerializeBytes, U24};
6
7use super::{Deserialize, Error, Serialize, Size};
8
9use core::marker::PhantomData;
10#[cfg(feature = "std")]
11use std::io::{Read, Write};
12
13impl<T: Size> Size for Option<T> {
14    #[inline]
15    fn tls_serialized_len(&self) -> usize {
16        1 + match self {
17            Some(v) => v.tls_serialized_len(),
18            None => 0,
19        }
20    }
21}
22
23impl<T: Size> Size for &Option<T> {
24    #[inline]
25    fn tls_serialized_len(&self) -> usize {
26        (*self).tls_serialized_len()
27    }
28}
29
30impl<T: Serialize> Serialize for Option<T> {
31    #[cfg(feature = "std")]
32    fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
33        match self {
34            Some(e) => {
35                let written = writer.write(&[1])?;
36                debug_assert_eq!(written, 1);
37                e.tls_serialize(writer).map(|l| l + 1)
38            }
39            None => {
40                writer.write_all(&[0])?;
41                Ok(1)
42            }
43        }
44    }
45}
46
47impl<T: SerializeBytes> SerializeBytes for Option<T> {
48    #[inline]
49    fn tls_serialize(&self) -> Result<Vec<u8>, Error> {
50        match self {
51            Some(e) => {
52                let mut out = Vec::with_capacity(e.tls_serialized_len() + 1);
53                out.push(1);
54                out.append(&mut e.tls_serialize()?);
55                Ok(out)
56            }
57            None => Ok(vec![0]),
58        }
59    }
60}
61
62impl<T: Serialize> Serialize for &Option<T> {
63    #[cfg(feature = "std")]
64    fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
65        (*self).tls_serialize(writer)
66    }
67}
68
69impl<T: SerializeBytes> SerializeBytes for &Option<T> {
70    #[inline]
71    fn tls_serialize(&self) -> Result<Vec<u8>, Error> {
72        (*self).tls_serialize()
73    }
74}
75
76impl<T: Deserialize> Deserialize for Option<T> {
77    #[cfg(feature = "std")]
78    #[inline]
79    fn tls_deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error> {
80        let mut some_or_none = [0u8; 1];
81        bytes.read_exact(&mut some_or_none)?;
82        match some_or_none[0] {
83            0 => {
84                Ok(None)
85            },
86            1 => {
87                let element = T::tls_deserialize(bytes)?;
88                Ok(Some(element))
89            },
90            _ => Err(Error::DecodingError(format!("Trying to decode Option<T> with {} for option. It must be 0 for None and 1 for Some.", some_or_none[0])))
91        }
92    }
93}
94
95impl<T: DeserializeBytes> DeserializeBytes for Option<T> {
96    #[inline]
97    fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
98        let (some_or_none, remainder) = <u8>::tls_deserialize_bytes(bytes)?;
99        match some_or_none {
100            0 => {
101                Ok((None, remainder))
102            },
103            1 => {
104                let (element, remainder) = T::tls_deserialize_bytes(remainder)?;
105                Ok((Some(element), remainder))
106            },
107            _ => Err(Error::DecodingError(alloc::format!("Trying to decode Option<T> with {} for option. It must be 0 for None and 1 for Some.", some_or_none)))
108        }
109    }
110}
111
112macro_rules! impl_unsigned {
113    ($t:ty, $bytes:literal) => {
114        impl Deserialize for $t {
115            #[cfg(feature = "std")]
116            #[inline]
117            fn tls_deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error> {
118                let mut x = <$t>::default().to_be_bytes();
119                bytes.read_exact(&mut x)?;
120                Ok(<$t>::from_be_bytes(x))
121            }
122        }
123
124        impl DeserializeBytes for $t {
125            #[inline]
126            fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
127                let len = core::mem::size_of::<$t>();
128                let out = bytes
129                    .get(..len)
130                    .ok_or(Error::EndOfStream)?
131                    .try_into()
132                    .map_err(|_| Error::EndOfStream)?;
133                Ok((
134                    <$t>::from_be_bytes(out),
135                    &bytes.get(len..).ok_or(Error::EndOfStream)?,
136                ))
137            }
138        }
139
140        impl SerializeBytes for &$t {
141            #[inline]
142            fn tls_serialize(&self) -> Result<Vec<u8>, Error> {
143                Ok(self.to_be_bytes().to_vec())
144            }
145        }
146
147        impl SerializeBytes for $t {
148            #[inline]
149            fn tls_serialize(&self) -> Result<Vec<u8>, Error> {
150                <&Self as SerializeBytes>::tls_serialize(&self)
151            }
152        }
153
154        impl Serialize for $t {
155            #[cfg(feature = "std")]
156            #[inline]
157            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
158                let written = writer.write(&self.to_be_bytes())?;
159                debug_assert_eq!(written, $bytes);
160                Ok(written)
161            }
162        }
163
164        impl Serialize for &$t {
165            #[cfg(feature = "std")]
166            #[inline]
167            fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
168                <$t as Serialize>::tls_serialize(self, writer)
169            }
170        }
171
172        impl Size for $t {
173            #[inline]
174            fn tls_serialized_len(&self) -> usize {
175                $bytes
176            }
177        }
178
179        impl Size for &$t {
180            #[inline]
181            fn tls_serialized_len(&self) -> usize {
182                (*self).tls_serialized_len()
183            }
184        }
185    };
186}
187
188impl_unsigned!(u8, 1);
189impl_unsigned!(u16, 2);
190impl_unsigned!(U24, 3);
191impl_unsigned!(u32, 4);
192impl_unsigned!(u64, 8);
193
194impl From<core::array::TryFromSliceError> for Error {
195    fn from(_: core::array::TryFromSliceError) -> Self {
196        Self::InvalidInput
197    }
198}
199
200// Implement (de)serialization for tuple.
201impl<T, U> Deserialize for (T, U)
202where
203    T: Deserialize,
204    U: Deserialize,
205{
206    #[cfg(feature = "std")]
207    #[inline(always)]
208    fn tls_deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error> {
209        Ok((T::tls_deserialize(bytes)?, U::tls_deserialize(bytes)?))
210    }
211}
212
213impl<T, U> DeserializeBytes for (T, U)
214where
215    T: DeserializeBytes,
216    U: DeserializeBytes,
217{
218    #[inline(always)]
219    fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
220        let (first_element, remainder) = T::tls_deserialize_bytes(bytes)?;
221        let (second_element, remainder) = U::tls_deserialize_bytes(remainder)?;
222        Ok(((first_element, second_element), remainder))
223    }
224}
225
226impl<T, U> Serialize for (T, U)
227where
228    T: Serialize,
229    U: Serialize,
230{
231    #[cfg(feature = "std")]
232    #[inline(always)]
233    fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
234        let written = self.0.tls_serialize(writer)?;
235        self.1.tls_serialize(writer).map(|l| l + written)
236    }
237}
238
239impl<T, U> Size for (T, U)
240where
241    T: Size,
242    U: Size,
243{
244    #[inline(always)]
245    fn tls_serialized_len(&self) -> usize {
246        self.0.tls_serialized_len() + self.1.tls_serialized_len()
247    }
248}
249
250impl<T, U, V> Deserialize for (T, U, V)
251where
252    T: Deserialize,
253    U: Deserialize,
254    V: Deserialize,
255{
256    #[cfg(feature = "std")]
257    #[inline(always)]
258    fn tls_deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error> {
259        Ok((
260            T::tls_deserialize(bytes)?,
261            U::tls_deserialize(bytes)?,
262            V::tls_deserialize(bytes)?,
263        ))
264    }
265}
266
267impl<T, U, V> DeserializeBytes for (T, U, V)
268where
269    T: DeserializeBytes,
270    U: DeserializeBytes,
271    V: DeserializeBytes,
272{
273    #[inline(always)]
274    fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
275        let (first_element, remainder) = T::tls_deserialize_bytes(bytes)?;
276        let (second_element, remainder) = U::tls_deserialize_bytes(remainder)?;
277        let (third_element, remainder) = V::tls_deserialize_bytes(remainder)?;
278        Ok(((first_element, second_element, third_element), remainder))
279    }
280}
281
282impl<T, U, V> Serialize for (T, U, V)
283where
284    T: Serialize,
285    U: Serialize,
286    V: Serialize,
287{
288    #[cfg(feature = "std")]
289    #[inline(always)]
290    fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
291        let mut written = self.0.tls_serialize(writer)?;
292        written += self.1.tls_serialize(writer)?;
293        self.2.tls_serialize(writer).map(|l| l + written)
294    }
295}
296
297impl<T, U, V> Size for (T, U, V)
298where
299    T: Size,
300    U: Size,
301    V: Size,
302{
303    #[inline(always)]
304    fn tls_serialized_len(&self) -> usize {
305        self.0.tls_serialized_len() + self.1.tls_serialized_len() + self.2.tls_serialized_len()
306    }
307}
308
309impl Size for () {
310    #[inline(always)]
311    fn tls_serialized_len(&self) -> usize {
312        0
313    }
314}
315
316impl Deserialize for () {
317    #[cfg(feature = "std")]
318    #[inline(always)]
319    fn tls_deserialize<R: Read>(_: &mut R) -> Result<(), Error> {
320        Ok(())
321    }
322}
323
324impl DeserializeBytes for () {
325    #[inline(always)]
326    fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
327        Ok(((), bytes))
328    }
329}
330
331impl Serialize for () {
332    #[cfg(feature = "std")]
333    fn tls_serialize<W: Write>(&self, _: &mut W) -> Result<usize, Error> {
334        Ok(0)
335    }
336}
337
338impl<T> Size for PhantomData<T> {
339    #[inline(always)]
340    fn tls_serialized_len(&self) -> usize {
341        0
342    }
343}
344
345impl<T> Deserialize for PhantomData<T> {
346    #[cfg(feature = "std")]
347    #[inline(always)]
348    fn tls_deserialize<R: Read>(_: &mut R) -> Result<Self, Error> {
349        Ok(PhantomData)
350    }
351}
352
353impl<T> DeserializeBytes for PhantomData<T> {
354    #[inline(always)]
355    fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
356        Ok((PhantomData, bytes))
357    }
358}
359
360impl<T> Serialize for PhantomData<T> {
361    #[cfg(feature = "std")]
362    #[inline(always)]
363    fn tls_serialize<W: Write>(&self, _: &mut W) -> Result<usize, Error> {
364        Ok(0)
365    }
366}
367
368impl<T> SerializeBytes for PhantomData<T> {
369    #[inline(always)]
370    fn tls_serialize(&self) -> Result<Vec<u8>, Error> {
371        Ok(vec![])
372    }
373}
374
375impl<T: Size> Size for Box<T> {
376    #[inline(always)]
377    fn tls_serialized_len(&self) -> usize {
378        self.as_ref().tls_serialized_len()
379    }
380}
381
382impl<T: Serialize> Serialize for Box<T> {
383    #[cfg(feature = "std")]
384    #[inline(always)]
385    fn tls_serialize<W: Write>(&self, writer: &mut W) -> Result<usize, Error> {
386        self.as_ref().tls_serialize(writer)
387    }
388}
389
390impl<T: SerializeBytes> SerializeBytes for Box<T> {
391    #[inline(always)]
392    fn tls_serialize(&self) -> Result<Vec<u8>, Error> {
393        self.as_ref().tls_serialize()
394    }
395}
396
397impl<T: Deserialize> Deserialize for Box<T> {
398    #[cfg(feature = "std")]
399    #[inline(always)]
400    fn tls_deserialize<R: Read>(bytes: &mut R) -> Result<Self, Error> {
401        T::tls_deserialize(bytes).map(Box::new)
402    }
403}
404
405impl<T: DeserializeBytes> DeserializeBytes for Box<T> {
406    #[inline(always)]
407    fn tls_deserialize_bytes(bytes: &[u8]) -> Result<(Self, &[u8]), Error> {
408        T::tls_deserialize_bytes(bytes).map(|(v, r)| (Box::new(v), r))
409    }
410}
tls_codec/primitives.rs

tls_codec/
primitives.rs
