oasis_amqp/
de.rs

1use std::convert::TryInto;
2use std::{fmt, str};
3
4use serde::de::{self, DeserializeSeed, EnumAccess, MapAccess, SeqAccess, VariantAccess, Visitor};
5
6use crate::{Described, Error};
7
8pub fn deserialize<'a, T: de::Deserialize<'a>>(bytes: &'a [u8]) -> Result<(T, &'a [u8])> {
9    let mut deserializer = Deserializer::from_bytes(bytes);
10    let val = T::deserialize(&mut deserializer)?;
11    Ok((val, deserializer.input))
12}
13
14pub struct Deserializer<'de> {
15    input: &'de [u8],
16    constructor: Option<usize>,
17    any: bool,
18}
19
20impl<'de> Deserializer<'de> {
21    pub fn from_bytes(input: &'de [u8]) -> Self {
22        Deserializer {
23            input,
24            constructor: None,
25            any: false,
26        }
27    }
28
29    fn peek(&self) -> Result<u8> {
30        self.input.get(0).copied().ok_or(Error::UnexpectedEnd)
31    }
32
33    fn next(&mut self) -> Result<u8> {
34        let res = self.peek();
35        self.input = &self.input[1..];
36        res
37    }
38
39    fn assume(&mut self, assumed: u8) -> Result<()> {
40        if let Ok(val) = self.next() {
41            assert_eq!(val, assumed);
42            Ok(())
43        } else {
44            Err(Error::UnexpectedEnd)
45        }
46    }
47
48    fn read_u32(&mut self) -> Result<u32> {
49        let (val, rest) = self.input.split_at(4);
50        self.input = rest;
51        Ok(u32::from_be_bytes(val.try_into()?))
52    }
53
54    fn parse_bool(&mut self) -> Result<bool> {
55        Ok(match self.next_constructor()? {
56            0x56 => match self.next()? {
57                0x01 => true,
58                0x00 => false,
59                v => return Err(InvalidFormatCode::new("bool", v).into()),
60            },
61            0x41 => true,
62            0x42 => false,
63            t => return Err(InvalidFormatCode::new("bool", t as u8).into()),
64        })
65    }
66
67    fn parse_descriptor(&mut self) -> Result<Descriptor<'de>> {
68        self.assume(0)?;
69        match self.peek()? {
70            0x44 | 0x53 | 0x80 => Ok(Descriptor::Numeric(self.parse_u64()?)),
71            0xa3 | 0xb3 => Ok(Descriptor::Symbol(self.parse_bytes()?)),
72            f => Err(InvalidFormatCode::new("descriptor", f).into()),
73        }
74    }
75
76    fn parse_u64(&mut self) -> Result<u64> {
77        Ok(match self.next()? {
78            0x44 => 0,
79            0x53 => self.next()? as u64,
80            0x80 => {
81                let (val, rest) = self.input.split_at(8);
82                self.input = rest;
83                let val = val.try_into()?;
84                u64::from_be_bytes(val)
85            }
86            t => return Err(InvalidFormatCode::new("u64", t).into()),
87        })
88    }
89
90    fn parse_bytes(&mut self) -> Result<&'de [u8]> {
91        let len = match self.next_constructor()? {
92            0xa0 | 0xa3 => self.next()? as usize,
93            0xb0 | 0xb3 => self.read_u32()? as usize,
94            t => return Err(InvalidFormatCode::new("bytes", t as u8).into()),
95        };
96
97        let (val, rest) = self.input.split_at(len);
98        self.input = rest;
99        Ok(val)
100    }
101
102    fn peek_constructor(&mut self) -> Result<usize> {
103        Ok(match self.constructor.as_ref() {
104            Some(v) => *v,
105            None => self.peek()? as usize,
106        })
107    }
108
109    fn next_constructor(&mut self) -> Result<usize> {
110        Ok(match self.constructor.as_ref() {
111            Some(v) => *v,
112            None => self.next()? as usize,
113        })
114    }
115
116    // size, len, constructor
117    fn composite(&mut self) -> Result<(usize, usize, Option<usize>)> {
118        Ok(match self.next()? {
119            0x45 => (0, 0, None),
120            0xc0 => (self.next()? as usize - 1, self.next()? as usize, None),
121            0xc1 => (self.next()? as usize - 1, self.next()? as usize, None),
122            0xd0 => (
123                self.read_u32()? as usize - 4,
124                self.read_u32()? as usize,
125                None,
126            ),
127            0xd1 => (
128                self.read_u32()? as usize - 4,
129                self.read_u32()? as usize,
130                None,
131            ),
132            0xe0 => (
133                self.next()? as usize - 2,
134                self.next()? as usize,
135                Some(self.next()? as usize),
136            ),
137            0xf0 => (
138                self.read_u32()? as usize - 8,
139                self.read_u32()? as usize,
140                Some(self.read_u32()? as usize),
141            ),
142            t => return Err(InvalidFormatCode::new("composite type", t).into()),
143        })
144    }
145
146    pub fn reader(&mut self) -> Result<DescribedReader<'de>> {
147        DescribedReader::new(self.parse_descriptor()?)
148    }
149}
150
151impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
152    type Error = Error;
153
154    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
155    where
156        V: Visitor<'de>,
157    {
158        match self.peek_constructor()? {
159            0x40 => self.deserialize_unit(visitor),
160            0x56 | 0x41 | 0x42 => self.deserialize_bool(visitor),
161            0x50 => self.deserialize_u8(visitor),
162            0x60 => self.deserialize_u16(visitor),
163            0x43 | 0x52 | 0x70 => self.deserialize_u32(visitor),
164            0x44 | 0x53 | 0x80 => self.deserialize_u64(visitor),
165            0x51 => self.deserialize_i8(visitor),
166            0x61 => self.deserialize_i16(visitor),
167            0x54 | 0x71 => self.deserialize_i32(visitor),
168            0x55 | 0x81 | 0x83 => self.deserialize_i64(visitor),
169            0x72 => self.deserialize_f32(visitor),
170            0x82 => self.deserialize_f64(visitor),
171            0x45 | 0xc0 | 0xd0 => self.deserialize_seq(visitor),
172            0x74 | 0x84 | 0x94 => unimplemented!(), // decimal32, decimal64, decimal128
173            0x73 => self.deserialize_char(visitor),
174            0xa1 | 0xb1 => self.deserialize_str(visitor),
175            0xa0 | 0xa3 | 0xb0 | 0xb3 => self.deserialize_bytes(visitor),
176            t => Err(InvalidFormatCode::new("any", t as u8).into()),
177        }
178    }
179
180    fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
181    where
182        V: Visitor<'de>,
183    {
184        visitor.visit_bool(self.parse_bool()?)
185    }
186
187    fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
188    where
189        V: Visitor<'de>,
190    {
191        self.assume(0x50)?;
192        visitor.visit_u8(self.next()?)
193    }
194
195    fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value>
196    where
197        V: Visitor<'de>,
198    {
199        self.assume(0x60)?;
200        let (val, rest) = self.input.split_at(2);
201        self.input = rest;
202        let val = val.try_into()?;
203        visitor.visit_u16(u16::from_be_bytes(val))
204    }
205
206    fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value>
207    where
208        V: Visitor<'de>,
209    {
210        match self.next()? {
211            0x43 => visitor.visit_u32(0),
212            0x52 => visitor.visit_u32(self.next()? as u32),
213            0x70 => visitor.visit_u32(self.read_u32()?),
214            t => Err(InvalidFormatCode::new("u32", t).into()),
215        }
216    }
217
218    fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value>
219    where
220        V: Visitor<'de>,
221    {
222        visitor.visit_u64(self.parse_u64()?)
223    }
224
225    fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
226    where
227        V: Visitor<'de>,
228    {
229        self.assume(0x51)?;
230        visitor.visit_i8(self.next()? as i8)
231    }
232
233    fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value>
234    where
235        V: Visitor<'de>,
236    {
237        self.assume(0x61)?;
238        let (val, rest) = self.input.split_at(2);
239        self.input = rest;
240        let val = val.try_into()?;
241        visitor.visit_i16(i16::from_be_bytes(val))
242    }
243
244    fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value>
245    where
246        V: Visitor<'de>,
247    {
248        match self.next()? {
249            0x54 => visitor.visit_i32(self.next()? as i32),
250            0x71 => {
251                let (val, rest) = self.input.split_at(4);
252                self.input = rest;
253                let val = val.try_into()?;
254                visitor.visit_i32(i32::from_be_bytes(val))
255            }
256            t => Err(InvalidFormatCode::new("i32", t).into()),
257        }
258    }
259
260    fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value>
261    where
262        V: Visitor<'de>,
263    {
264        match self.next()? {
265            0x55 => visitor.visit_i64(self.next()? as i64),
266            0x81 | 0x83 => {
267                let (val, rest) = self.input.split_at(8);
268                self.input = rest;
269                let val = val.try_into()?;
270                visitor.visit_i64(i64::from_be_bytes(val))
271            }
272            t => Err(InvalidFormatCode::new("i64", t).into()),
273        }
274    }
275
276    fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
277    where
278        V: Visitor<'de>,
279    {
280        self.assume(0x72)?;
281        visitor.visit_f32(f32::from_bits(self.read_u32()?))
282    }
283
284    fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
285    where
286        V: Visitor<'de>,
287    {
288        self.assume(0x82)?;
289        let (val, rest) = self.input.split_at(8);
290        self.input = rest;
291        let val = u64::from_be_bytes(val.try_into()?);
292        visitor.visit_f64(f64::from_bits(val))
293    }
294
295    fn deserialize_char<V>(self, _visitor: V) -> Result<V::Value>
296    where
297        V: Visitor<'de>,
298    {
299        unimplemented!()
300    }
301
302    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
303    where
304        V: Visitor<'de>,
305    {
306        let len = match self.next_constructor()? {
307            0xa1 | 0xa3 => self.next()? as usize,
308            0xb1 | 0xb3 => self.read_u32()? as usize,
309            t => return Err(InvalidFormatCode::new("str", t as u8).into()),
310        };
311
312        let (val, rest) = self.input.split_at(len);
313        self.input = rest;
314        match str::from_utf8(val) {
315            Ok(s) => visitor.visit_borrowed_str(s),
316            Err(_) => Err(Error::InvalidData),
317        }
318    }
319
320    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
321    where
322        V: Visitor<'de>,
323    {
324        self.deserialize_str(visitor)
325    }
326
327    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
328    where
329        V: Visitor<'de>,
330    {
331        visitor.visit_borrowed_bytes(self.parse_bytes()?)
332    }
333
334    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
335    where
336        V: Visitor<'de>,
337    {
338        visitor.visit_byte_buf(self.parse_bytes()?.to_owned())
339    }
340
341    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
342    where
343        V: Visitor<'de>,
344    {
345        if self.input.is_empty() {
346            visitor.visit_none()
347        } else if self.peek()? == 0x40 {
348            self.assume(0x40)?;
349            visitor.visit_none()
350        } else {
351            visitor.visit_some(self)
352        }
353    }
354
355    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
356    where
357        V: Visitor<'de>,
358    {
359        self.assume(0x40)?;
360        visitor.visit_unit()
361    }
362
363    fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
364    where
365        V: Visitor<'de>,
366    {
367        self.deserialize_unit(visitor)
368    }
369
370    fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
371    where
372        V: Visitor<'de>,
373    {
374        visitor.visit_newtype_struct(self)
375    }
376
377    fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
378    where
379        V: Visitor<'de>,
380    {
381        // Ignore potential descriptors, which are likely here because
382        // Corda confuses (heterogeneous) lists and (homogeneous) arrays.
383        if self.peek()? == 0 {
384            let _ = self.parse_descriptor()?;
385        }
386
387        let (size, len, constructor) = self.composite()?;
388        let (input, rest) = self.input.split_at(size);
389        self.input = rest;
390
391        let mut nested = Deserializer {
392            input,
393            constructor,
394            any: false,
395        };
396        visitor.visit_seq(Access {
397            de: &mut nested,
398            len,
399        })
400    }
401
402    fn deserialize_tuple<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
403    where
404        V: Visitor<'de>,
405    {
406        unimplemented!()
407    }
408
409    fn deserialize_tuple_struct<V>(
410        self,
411        _name: &'static str,
412        _len: usize,
413        visitor: V,
414    ) -> Result<V::Value>
415    where
416        V: Visitor<'de>,
417    {
418        self.deserialize_seq(visitor)
419    }
420
421    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value>
422    where
423        V: Visitor<'de>,
424    {
425        let (_, len, _) = self.composite()?;
426        visitor.visit_map(Map::new(&mut self, len / 2))
427    }
428
429    fn deserialize_struct<V>(
430        self,
431        _name: &'static str,
432        fields: &'static [&'static str],
433        visitor: V,
434    ) -> Result<V::Value>
435    where
436        V: Visitor<'de>,
437    {
438        if self.peek()? == 0 {
439            let _ = self.parse_descriptor()?;
440        }
441
442        let (size, _, constructor) = self.composite()?;
443        let (input, rest) = self.input.split_at(size);
444        self.input = rest;
445
446        let mut nested = Deserializer {
447            input,
448            constructor,
449            any: false,
450        };
451        visitor.visit_seq(Access {
452            de: &mut nested,
453            len: fields.len(),
454        })
455    }
456
457    fn deserialize_enum<V>(
458        self,
459        name: &'static str,
460        _variants: &'static [&'static str],
461        visitor: V,
462    ) -> Result<V::Value>
463    where
464        V: Visitor<'de>,
465    {
466        if self.peek_constructor()? == 0 {
467            self.assume(0)?;
468            visitor.visit_enum(Enum { de: self })
469        } else {
470            self.any = name == "Any";
471            let res = visitor.visit_enum(Enum { de: self });
472            self.any = false;
473            res
474        }
475    }
476
477    fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value>
478    where
479        V: Visitor<'de>,
480    {
481        if !self.any {
482            match self.peek_constructor()? {
483                0x56 | 0x41 | 0x42 => visitor.visit_u64(if self.parse_bool()? { 1 } else { 0 }),
484                0x50 => {
485                    self.assume(0x50)?;
486                    let id = self.next()?;
487                    visitor.visit_u64(id as u64)
488                }
489                0x43 | 0x52 | 0x70 => visitor.visit_u64(self.read_u32()? as u64),
490                0x44 | 0x53 | 0x80 => self.deserialize_u64(visitor),
491                0xa3 | 0xb3 => self.deserialize_bytes(visitor),
492                t => Err(InvalidFormatCode::new("variant identifier", t as u8).into()),
493            }
494        } else {
495            visitor.visit_u64(self.peek_constructor()? as u64)
496        }
497    }
498
499    fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value>
500    where
501        V: Visitor<'de>,
502    {
503        self.deserialize_any(visitor)
504    }
505}
506
507pub struct DescribedReader<'de> {
508    descriptor: Option<Descriptor<'de>>,
509}
510
511impl<'de> DescribedReader<'de> {
512    pub fn new(descriptor: Descriptor<'de>) -> Result<Self> {
513        Ok(Self {
514            descriptor: Some(descriptor),
515        })
516    }
517
518    pub fn next(&mut self, deserializer: &mut Deserializer<'de>) -> Result<()> {
519        if !deserializer.input.is_empty() {
520            self.descriptor = Some(deserializer.parse_descriptor()?);
521        }
522        Ok(())
523    }
524
525    pub fn read<T: Described + serde::de::Deserialize<'de>>(
526        &mut self,
527        deserializer: &mut Deserializer<'de>,
528        next: bool,
529    ) -> Result<Option<T>> {
530        use Descriptor::*;
531        let matched = match &self.descriptor {
532            Some(Numeric(v)) => T::CODE == Some(*v),
533            Some(Symbol(s)) => T::NAME == Some(s),
534            None => return Ok(None),
535        };
536
537        if !matched {
538            return Ok(None);
539        }
540
541        let t = T::deserialize(&mut *deserializer)?;
542        if next {
543            self.next(deserializer)?;
544        }
545        Ok(Some(t))
546    }
547}
548
549pub enum Descriptor<'a> {
550    Numeric(u64),
551    Symbol(&'a [u8]),
552}
553
554struct Access<'a, 'de: 'a> {
555    de: &'a mut Deserializer<'de>,
556    len: usize,
557}
558
559impl<'a, 'de> SeqAccess<'de> for Access<'a, 'de> {
560    type Error = Error;
561
562    fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
563    where
564        T: DeserializeSeed<'de>,
565    {
566        if self.len > 0 {
567            self.len -= 1;
568            Ok(Some(seed.deserialize(&mut *self.de)?))
569        } else {
570            Ok(None)
571        }
572    }
573
574    fn size_hint(&self) -> Option<usize> {
575        Some(self.len)
576    }
577}
578
579struct Enum<'a, 'de: 'a> {
580    de: &'a mut Deserializer<'de>,
581}
582
583impl<'de, 'a> EnumAccess<'de> for Enum<'a, 'de> {
584    type Error = Error;
585    type Variant = Self;
586
587    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
588    where
589        V: DeserializeSeed<'de>,
590    {
591        Ok((seed.deserialize(&mut *self.de)?, self))
592    }
593}
594
595impl<'de, 'a> VariantAccess<'de> for Enum<'a, 'de> {
596    type Error = Error;
597
598    fn unit_variant(self) -> Result<()> {
599        Ok(())
600    }
601
602    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
603    where
604        T: DeserializeSeed<'de>,
605    {
606        seed.deserialize(self.de)
607    }
608
609    fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value>
610    where
611        V: Visitor<'de>,
612    {
613        unimplemented!()
614    }
615
616    fn struct_variant<V>(self, _fields: &'static [&'static str], _visitor: V) -> Result<V::Value>
617    where
618        V: Visitor<'de>,
619    {
620        unimplemented!()
621    }
622}
623
624struct Map<'a, 'de: 'a> {
625    de: &'a mut Deserializer<'de>,
626    left: usize,
627}
628
629impl<'a, 'de> Map<'a, 'de> {
630    fn new(de: &'a mut Deserializer<'de>, left: usize) -> Self {
631        Self { de, left }
632    }
633}
634
635impl<'de, 'a> MapAccess<'de> for Map<'a, 'de> {
636    type Error = Error;
637
638    fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
639    where
640        K: DeserializeSeed<'de>,
641    {
642        if self.left < 1 {
643            return Ok(None);
644        }
645        self.left -= 1;
646        seed.deserialize(&mut *self.de).map(Some)
647    }
648
649    fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
650    where
651        V: DeserializeSeed<'de>,
652    {
653        seed.deserialize(&mut *self.de)
654    }
655}
656
657#[derive(Debug)]
658pub struct InvalidFormatCode {
659    expected: &'static str,
660    code: u8,
661}
662
663impl InvalidFormatCode {
664    fn new(expected: &'static str, code: u8) -> Self {
665        Self { expected, code }
666    }
667}
668
669impl std::error::Error for InvalidFormatCode {}
670
671impl fmt::Display for InvalidFormatCode {
672    fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
673        write!(
674            formatter,
675            "expected {}, found format code {:?}",
676            self.expected, self.code
677        )
678    }
679}
680
681type Result<T> = std::result::Result<T, Error>;
oasis_amqp/de.rs

oasis_amqp/
de.rs
