scuffle_amf0/
decoder.rs

1//! AMF0 decoder
2
3use std::io;
4
5use byteorder::{BigEndian, ReadBytesExt};
6use num_traits::FromPrimitive;
7use scuffle_bytes_util::StringCow;
8use scuffle_bytes_util::zero_copy::ZeroCopyReader;
9
10use crate::{Amf0Array, Amf0Error, Amf0Marker, Amf0Object, Amf0Value};
11
12/// AMF0 decoder.
13///
14/// Provides various functions to decode different types of AMF0 values.
15#[derive(Debug, Clone)]
16pub struct Amf0Decoder<R> {
17    pub(crate) reader: R,
18    pub(crate) next_marker: Option<Amf0Marker>,
19}
20
21#[derive(Debug, Clone, PartialEq, Eq)]
22pub(crate) enum ObjectHeader<'a> {
23    Object,
24    TypedObject { name: StringCow<'a> },
25    EcmaArray { size: u32 },
26}
27
28impl<B> Amf0Decoder<scuffle_bytes_util::zero_copy::BytesBuf<B>>
29where
30    B: bytes::Buf,
31{
32    /// Create a new deserializer from a buffer implementing [`bytes::Buf`].
33    pub fn from_buf(buf: B) -> Self {
34        Self {
35            reader: buf.into(),
36            next_marker: None,
37        }
38    }
39}
40
41impl<R> Amf0Decoder<scuffle_bytes_util::zero_copy::IoRead<R>>
42where
43    R: std::io::Read,
44{
45    /// Create a new deserializer from a reader implementing [`std::io::Read`].
46    pub fn from_reader(reader: R) -> Self {
47        Self {
48            reader: reader.into(),
49            next_marker: None,
50        }
51    }
52}
53
54impl<'a> Amf0Decoder<scuffle_bytes_util::zero_copy::Slice<'a>> {
55    /// Create a new deserializer from a byte slice.
56    pub fn from_slice(slice: &'a [u8]) -> Amf0Decoder<scuffle_bytes_util::zero_copy::Slice<'a>> {
57        Self {
58            reader: slice.into(),
59            next_marker: None,
60        }
61    }
62}
63
64impl<'a, R> Amf0Decoder<R>
65where
66    R: ZeroCopyReader<'a>,
67{
68    /// Decode a [`Amf0Value`] from the buffer.
69    pub fn decode_value(&mut self) -> Result<Amf0Value<'a>, Amf0Error> {
70        let marker = self.peek_marker()?;
71
72        match marker {
73            Amf0Marker::Boolean => self.decode_boolean().map(Into::into),
74            Amf0Marker::Number | Amf0Marker::Date => self.decode_number().map(Into::into),
75            Amf0Marker::String | Amf0Marker::LongString | Amf0Marker::XmlDocument => self.decode_string().map(Into::into),
76            Amf0Marker::Null | Amf0Marker::Undefined => self.decode_null().map(|_| Amf0Value::Null),
77            Amf0Marker::Object | Amf0Marker::TypedObject | Amf0Marker::EcmaArray => self.decode_object().map(Into::into),
78            Amf0Marker::StrictArray => self.decode_strict_array().map(Into::into),
79            _ => Err(Amf0Error::UnsupportedMarker(marker)),
80        }
81    }
82
83    /// Decode all values from the buffer until the end.
84    pub fn decode_all(&mut self) -> Result<Vec<Amf0Value<'a>>, Amf0Error> {
85        let mut values = Vec::new();
86
87        while self.has_remaining()? {
88            values.push(self.decode_value()?);
89        }
90
91        Ok(values)
92    }
93
94    /// Convert the decoder into an iterator over the values in the buffer.
95    pub fn stream(&mut self) -> Amf0DecoderStream<'_, 'a, R> {
96        Amf0DecoderStream {
97            decoder: self,
98            _marker: std::marker::PhantomData,
99        }
100    }
101
102    /// Check if there are any values left in the buffer.
103    pub fn has_remaining(&mut self) -> Result<bool, Amf0Error> {
104        match self.peek_marker() {
105            Ok(_) => Ok(true),
106            Err(Amf0Error::Io(e)) if e.kind() == io::ErrorKind::UnexpectedEof => Ok(false),
107            Err(err) => Err(err),
108        }
109    }
110
111    /// Peek the next marker in the buffer without consuming it.
112    pub fn peek_marker(&mut self) -> Result<Amf0Marker, Amf0Error> {
113        let marker = self.read_marker()?;
114        // Buffer the marker for the next read
115        self.next_marker = Some(marker);
116
117        Ok(marker)
118    }
119
120    fn read_marker(&mut self) -> Result<Amf0Marker, Amf0Error> {
121        if let Some(marker) = self.next_marker.take() {
122            return Ok(marker);
123        }
124
125        let marker = self.reader.as_std().read_u8()?;
126        let marker = Amf0Marker::from_u8(marker).ok_or(Amf0Error::UnknownMarker(marker))?;
127        Ok(marker)
128    }
129
130    fn expect_marker(&mut self, expect: &'static [Amf0Marker]) -> Result<Amf0Marker, Amf0Error> {
131        let marker = self.read_marker()?;
132
133        if !expect.contains(&marker) {
134            Err(Amf0Error::UnexpectedType {
135                expected: expect,
136                got: marker,
137            })
138        } else {
139            Ok(marker)
140        }
141    }
142
143    /// Decode a number from the buffer.
144    pub fn decode_number(&mut self) -> Result<f64, Amf0Error> {
145        let marker = self.expect_marker(&[Amf0Marker::Number, Amf0Marker::Date])?;
146
147        let number = self.reader.as_std().read_f64::<BigEndian>()?;
148
149        if marker == Amf0Marker::Date {
150            // Skip the timezone
151            self.reader.as_std().read_i16::<BigEndian>()?;
152        }
153
154        Ok(number)
155    }
156
157    /// Decode a boolean from the buffer.
158    pub fn decode_boolean(&mut self) -> Result<bool, Amf0Error> {
159        self.expect_marker(&[Amf0Marker::Boolean])?;
160        let value = self.reader.as_std().read_u8()?;
161        Ok(value != 0)
162    }
163
164    pub(crate) fn decode_normal_string(&mut self) -> Result<StringCow<'a>, Amf0Error> {
165        let len = self.reader.as_std().read_u16::<BigEndian>()? as usize;
166
167        let bytes = self.reader.try_read(len)?;
168        Ok(StringCow::from_bytes(bytes.into_bytes().try_into()?))
169    }
170
171    /// Decode a string from the buffer.
172    ///
173    /// This function can decode both normal strings and long strings.
174    pub fn decode_string(&mut self) -> Result<StringCow<'a>, Amf0Error> {
175        let marker = self.expect_marker(&[Amf0Marker::String, Amf0Marker::LongString, Amf0Marker::XmlDocument])?;
176
177        let len = if marker == Amf0Marker::String {
178            self.reader.as_std().read_u16::<BigEndian>()? as usize
179        } else {
180            // LongString or XmlDocument
181            self.reader.as_std().read_u32::<BigEndian>()? as usize
182        };
183
184        let bytes = self.reader.try_read(len)?;
185        Ok(StringCow::from_bytes(bytes.into_bytes().try_into()?))
186    }
187
188    /// Decode a null value from the buffer.
189    ///
190    /// This function can also decode undefined values.
191    pub fn decode_null(&mut self) -> Result<(), Amf0Error> {
192        self.expect_marker(&[Amf0Marker::Null, Amf0Marker::Undefined])?;
193        Ok(())
194    }
195
196    /// Deserialize a value from the buffer using [serde].
197    #[cfg(feature = "serde")]
198    pub fn deserialize<T>(&mut self) -> Result<T, Amf0Error>
199    where
200        T: serde::de::Deserialize<'a>,
201    {
202        T::deserialize(self)
203    }
204
205    /// Deserialize a stream of values from the buffer using [serde].
206    #[cfg(feature = "serde")]
207    pub fn deserialize_stream<T>(&mut self) -> crate::de::Amf0DeserializerStream<'_, R, T>
208    where
209        T: serde::de::Deserialize<'a>,
210    {
211        crate::de::Amf0DeserializerStream::new(self)
212    }
213
214    // --- Object and Ecma array ---
215
216    pub(crate) fn decode_object_header(&mut self) -> Result<ObjectHeader<'a>, Amf0Error> {
217        let marker = self.expect_marker(&[Amf0Marker::Object, Amf0Marker::TypedObject, Amf0Marker::EcmaArray])?;
218
219        if marker == Amf0Marker::Object {
220            Ok(ObjectHeader::Object)
221        } else if marker == Amf0Marker::TypedObject {
222            let name = self.decode_normal_string()?;
223            Ok(ObjectHeader::TypedObject { name })
224        } else {
225            // EcmaArray
226            let size = self.reader.as_std().read_u32::<BigEndian>()?;
227            Ok(ObjectHeader::EcmaArray { size })
228        }
229    }
230
231    pub(crate) fn decode_object_key(&mut self) -> Result<Option<StringCow<'a>>, Amf0Error> {
232        // Object keys are not preceeded with a marker and are always normal strings
233        let key = self.decode_normal_string()?;
234
235        // The object end marker is preceeded by an empty string
236        if key.as_str().is_empty() {
237            // Check if the next marker is an object end marker
238            if self.peek_marker()? == Amf0Marker::ObjectEnd {
239                // Clear the next marker buffer
240                self.next_marker = None;
241
242                return Ok(None);
243            }
244        }
245
246        Ok(Some(key))
247    }
248
249    /// Decode an object from the buffer.
250    ///
251    /// This function can decode normal objects, typed objects and ECMA arrays.
252    pub fn decode_object(&mut self) -> Result<Amf0Object<'a>, Amf0Error> {
253        let header = self.decode_object_header()?;
254
255        match header {
256            ObjectHeader::Object | ObjectHeader::TypedObject { .. } => {
257                let mut object = Amf0Object::new();
258
259                while let Some(key) = self.decode_object_key()? {
260                    let value = self.decode_value()?;
261                    object.insert(key, value);
262                }
263
264                Ok(object)
265            }
266            ObjectHeader::EcmaArray { size } => {
267                let mut object = Amf0Object::with_capacity(size as usize);
268
269                for _ in 0..size {
270                    // Object keys are not preceeded with a marker and are always normal strings
271                    let key = self.decode_normal_string()?;
272                    let value = self.decode_value()?;
273                    object.insert(key, value);
274                }
275
276                // There might be an object end marker after the last key
277                if self.has_remaining()? && self.peek_marker()? == Amf0Marker::ObjectEnd {
278                    // Clear the next marker buffer
279                    self.next_marker = None;
280                }
281
282                Ok(object)
283            }
284        }
285    }
286
287    // --- Strict array ---
288
289    pub(crate) fn decode_strict_array_header(&mut self) -> Result<u32, Amf0Error> {
290        self.expect_marker(&[Amf0Marker::StrictArray])?;
291        let size = self.reader.as_std().read_u32::<BigEndian>()?;
292
293        Ok(size)
294    }
295
296    /// Decode a strict array from the buffer.
297    pub fn decode_strict_array(&mut self) -> Result<Amf0Array<'a>, Amf0Error> {
298        let size = self.decode_strict_array_header()? as usize;
299
300        let mut array = Vec::with_capacity(size);
301
302        for _ in 0..size {
303            let value = self.decode_value()?;
304            array.push(value);
305        }
306
307        Ok(Amf0Array::from(array))
308    }
309}
310
311/// An iterator over the values in the buffer.
312///
313/// Yields values of type [`Amf0Value`] until the end of the buffer is reached.
314#[must_use = "Iterators are lazy and do nothing unless consumed"]
315pub struct Amf0DecoderStream<'a, 'de, R> {
316    decoder: &'a mut Amf0Decoder<R>,
317    _marker: std::marker::PhantomData<&'de ()>,
318}
319
320impl<'de, R: ZeroCopyReader<'de>> Iterator for Amf0DecoderStream<'_, 'de, R> {
321    type Item = Result<Amf0Value<'de>, Amf0Error>;
322
323    fn next(&mut self) -> Option<Self::Item> {
324        match self.decoder.has_remaining() {
325            Ok(true) => Some(self.decoder.decode_value()),
326            Ok(false) => None,
327            Err(err) => Some(Err(err)),
328        }
329    }
330}
331
332impl<'de, R> std::iter::FusedIterator for Amf0DecoderStream<'_, 'de, R> where R: ZeroCopyReader<'de> {}
333
334#[cfg(test)]
335#[cfg_attr(all(test, coverage_nightly), coverage(off))]
336mod tests {
337    use super::Amf0Decoder;
338    use crate::{Amf0Marker, Amf0Value};
339
340    #[test]
341    fn strict_array() {
342        #[rustfmt::skip]
343        let bytes = [
344            Amf0Marker::StrictArray as u8,
345            0, 0, 0, 2, // size
346            Amf0Marker::String as u8,
347            0, 3, b'v', b'a', b'l', // value
348            Amf0Marker::Boolean as u8,
349            1, // value
350        ];
351
352        let mut decoder = Amf0Decoder::from_slice(&bytes);
353        let array = decoder.decode_strict_array().unwrap();
354        assert_eq!(array.len(), 2);
355        assert_eq!(array[0], Amf0Value::String("val".into()));
356        assert_eq!(array[1], Amf0Value::Boolean(true));
357    }
358
359    #[test]
360    fn ecma_array() {
361        #[rustfmt::skip]
362        let bytes = [
363            Amf0Marker::EcmaArray as u8,
364            0, 0, 0, 2, // size
365            0, 3, b'a', b'b', b'c', // key
366            Amf0Marker::String as u8,
367            0, 3, b'v', b'a', b'l', // value
368            0, 4, b'd', b'e', b'f', b'g', // key
369            Amf0Marker::Boolean as u8,
370            1, // value
371        ];
372
373        let mut decoder = Amf0Decoder::from_slice(&bytes);
374        let object = decoder.decode_object().unwrap();
375        assert_eq!(object.len(), 2);
376        assert_eq!(*object.get(&"abc".into()).unwrap(), Amf0Value::String("val".into()));
377        assert_eq!(*object.get(&"defg".into()).unwrap(), Amf0Value::Boolean(true));
378    }
379
380    #[test]
381    fn decoder_stream() {
382        #[rustfmt::skip]
383        let bytes = [
384            Amf0Marker::Boolean as u8,
385            1, // value
386            Amf0Marker::String as u8,
387            0, 3, b'a', b'b', b'c', // value
388            Amf0Marker::Null as u8,
389        ];
390
391        let mut decoder = Amf0Decoder::from_slice(&bytes);
392        let mut stream = decoder.stream();
393        assert_eq!(stream.next().unwrap().unwrap(), Amf0Value::Boolean(true));
394        assert_eq!(stream.next().unwrap().unwrap(), Amf0Value::String("abc".into()));
395        assert_eq!(stream.next().unwrap().unwrap(), Amf0Value::Null);
396        assert!(stream.next().is_none());
397    }
398}
scuffle_amf0/decoder.rs

scuffle_amf0/
decoder.rs
