bincode/features/serde/
de_owned.rs

1use super::de_policy::{Ordinary, Policy, Untrusted};
2use super::DeserializeUntrusted;
3use super::{de_borrowed::borrow_decode_from_slice, DecodeError as SerdeDecodeError};
4use crate::de::UntrustedDecoder;
5use crate::{
6    config::Config,
7    de::{read::Reader, Decode, Decoder, DecoderImpl},
8    error::DecodeError,
9};
10use serde::de::*;
11
12#[cfg(feature = "std")]
13use crate::features::IoReader;
14
15/// Serde decoder encapsulating an owned reader.
16pub struct OwnedSerdeDecoder<DE: Decoder> {
17    pub(super) de: DE,
18}
19
20impl<DE: Decoder> OwnedSerdeDecoder<DE> {
21    /// Return a type implementing `serde::Deserializer`.
22    pub fn as_deserializer<'a>(
23        &'a mut self,
24    ) -> impl for<'de> serde::Deserializer<'de, Error = DecodeError> + 'a {
25        SerdeDecoder {
26            de: &mut self.de,
27            policy: Ordinary,
28        }
29    }
30}
31
32#[cfg(feature = "std")]
33impl<'r, C: Config, R: std::io::Read> OwnedSerdeDecoder<DecoderImpl<IoReader<&'r mut R>, C, ()>> {
34    /// Create a standard-reader decoder with the [untrusted collection safeguards](crate#untrusted-input).
35    pub fn from_std_read_untrusted(
36        src: &'r mut R,
37        config: C,
38    ) -> OwnedUntrustedSerdeDecoder<DecoderImpl<IoReader<&'r mut R>, C, (), true>> {
39        OwnedUntrustedSerdeDecoder {
40            inner: OwnedSerdeDecoder {
41                de: DecoderImpl::new_untrusted(IoReader::new(src), config, ()),
42            },
43        }
44    }
45
46    /// Creates the decoder from an `std::io::Read` implementor.
47    pub fn from_std_read(
48        src: &'r mut R,
49        config: C,
50    ) -> OwnedSerdeDecoder<DecoderImpl<IoReader<&'r mut R>, C, ()>>
51    where
52        C: Config,
53    {
54        let reader = IoReader::new(src);
55        let decoder = DecoderImpl::new(reader, config, ());
56        Self { de: decoder }
57    }
58}
59
60impl<C: Config, R: Reader> OwnedSerdeDecoder<DecoderImpl<R, C, ()>> {
61    /// Create a custom-reader decoder with the [untrusted collection safeguards](crate#untrusted-input).
62    pub fn from_reader_untrusted(
63        reader: R,
64        config: C,
65    ) -> OwnedUntrustedSerdeDecoder<DecoderImpl<R, C, (), true>> {
66        OwnedUntrustedSerdeDecoder {
67            inner: OwnedSerdeDecoder {
68                de: DecoderImpl::new_untrusted(reader, config, ()),
69            },
70        }
71    }
72
73    /// Creates the decoder from a [`Reader`] implementor.
74    pub fn from_reader(reader: R, config: C) -> OwnedSerdeDecoder<DecoderImpl<R, C, ()>>
75    where
76        C: Config,
77    {
78        let decoder = DecoderImpl::new(reader, config, ());
79        Self { de: decoder }
80    }
81}
82
83/// Attempt to decode a given type `D` from the given slice. Returns the decoded output and the amount of bytes read.
84///
85/// Note that this does not work with borrowed types like `&str` or `&[u8]`. For that use [borrow_decode_from_slice].
86///
87/// See the [config] module for more information on configurations.
88///
89/// [borrow_decode_from_slice]: fn.borrow_decode_from_slice.html
90/// [config]: ../config/index.html
91pub fn decode_from_slice<D, C>(slice: &[u8], config: C) -> Result<(D, usize), DecodeError>
92where
93    D: DeserializeOwned,
94    C: Config,
95{
96    borrow_decode_from_slice(slice, config)
97}
98
99/// Decode type `D` from the given reader with the given `Config`. The reader can be any type that implements `std::io::Read`, e.g. `std::fs::File`.
100///
101/// See the [config] module for more information about config options.
102///
103/// [config]: ../config/index.html
104#[cfg(feature = "std")]
105#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
106pub fn decode_from_std_read<'r, D: DeserializeOwned, C: Config, R: std::io::Read>(
107    src: &'r mut R,
108    config: C,
109) -> Result<D, DecodeError> {
110    let mut serde_decoder =
111        OwnedSerdeDecoder::<DecoderImpl<IoReader<&'r mut R>, C, ()>>::from_std_read(src, config);
112    D::deserialize(serde_decoder.as_deserializer())
113}
114
115/// Attempt to decode a given type `D` from the given [Reader].
116///
117/// See the [config] module for more information on configurations.
118///
119/// [config]: ../config/index.html
120pub fn decode_from_reader<D: DeserializeOwned, R: Reader, C: Config>(
121    reader: R,
122    config: C,
123) -> Result<D, DecodeError> {
124    let mut serde_decoder = OwnedSerdeDecoder::<DecoderImpl<R, C, ()>>::from_reader(reader, config);
125    D::deserialize(serde_decoder.as_deserializer())
126}
127
128/// Decode from a slice with the [untrusted collection safeguards](crate#untrusted-input).
129/// Returns the decoded value and the number of bytes consumed.
130pub fn decode_from_slice_untrusted<D: for<'de> DeserializeUntrusted<'de>, C: Config>(
131    slice: &[u8],
132    config: C,
133) -> Result<(D, usize), DecodeError> {
134    super::de_borrowed::borrow_decode_from_slice_untrusted(slice, config)
135}
136
137/// Decode from a standard reader with the [untrusted collection safeguards](crate#untrusted-input).
138#[cfg(feature = "std")]
139#[cfg_attr(docsrs, doc(cfg(feature = "std")))]
140pub fn decode_from_std_read_untrusted<
141    D: for<'de> DeserializeUntrusted<'de>,
142    C: Config,
143    R: std::io::Read,
144>(
145    src: &mut R,
146    config: C,
147) -> Result<D, DecodeError> {
148    let mut decoder = OwnedSerdeDecoder::from_std_read_untrusted(src, config);
149    decoder.decode()
150}
151
152/// Decode from a custom reader with the [untrusted collection safeguards](crate#untrusted-input).
153pub fn decode_from_reader_untrusted<D: for<'de> DeserializeUntrusted<'de>, R: Reader, C: Config>(
154    reader: R,
155    config: C,
156) -> Result<D, DecodeError> {
157    let mut decoder = OwnedSerdeDecoder::from_reader_untrusted(reader, config);
158    decoder.decode()
159}
160
161pub(super) struct SerdeDecoder<'a, DE: Decoder, P: Policy<DE>> {
162    pub(super) de: &'a mut DE,
163    pub(super) policy: P,
164}
165
166impl<'de, DE: Decoder, P: Policy<DE>> Deserializer<'de> for SerdeDecoder<'_, DE, P> {
167    type Error = DecodeError;
168
169    fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
170    where
171        V: serde::de::Visitor<'de>,
172    {
173        Err(SerdeDecodeError::AnyNotSupported.into())
174    }
175
176    fn deserialize_bool<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
177    where
178        V: serde::de::Visitor<'de>,
179    {
180        visitor.visit_bool(Decode::decode(&mut self.de)?)
181    }
182
183    fn deserialize_i8<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
184    where
185        V: serde::de::Visitor<'de>,
186    {
187        visitor.visit_i8(Decode::decode(&mut self.de)?)
188    }
189
190    fn deserialize_i16<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
191    where
192        V: serde::de::Visitor<'de>,
193    {
194        visitor.visit_i16(Decode::decode(&mut self.de)?)
195    }
196
197    fn deserialize_i32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
198    where
199        V: serde::de::Visitor<'de>,
200    {
201        visitor.visit_i32(Decode::decode(&mut self.de)?)
202    }
203
204    fn deserialize_i64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
205    where
206        V: serde::de::Visitor<'de>,
207    {
208        visitor.visit_i64(Decode::decode(&mut self.de)?)
209    }
210
211    serde::serde_if_integer128! {
212        fn deserialize_i128<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
213        where
214            V: serde::de::Visitor<'de>,
215        {
216            visitor.visit_i128(Decode::decode(&mut self.de)?)
217        }
218    }
219
220    fn deserialize_u8<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
221    where
222        V: serde::de::Visitor<'de>,
223    {
224        visitor.visit_u8(Decode::decode(&mut self.de)?)
225    }
226
227    fn deserialize_u16<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
228    where
229        V: serde::de::Visitor<'de>,
230    {
231        visitor.visit_u16(Decode::decode(&mut self.de)?)
232    }
233
234    fn deserialize_u32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
235    where
236        V: serde::de::Visitor<'de>,
237    {
238        visitor.visit_u32(Decode::decode(&mut self.de)?)
239    }
240
241    fn deserialize_u64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
242    where
243        V: serde::de::Visitor<'de>,
244    {
245        visitor.visit_u64(Decode::decode(&mut self.de)?)
246    }
247
248    serde::serde_if_integer128! {
249        fn deserialize_u128<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
250        where
251            V: serde::de::Visitor<'de>,
252        {
253            visitor.visit_u128(Decode::decode(&mut self.de)?)
254        }
255    }
256
257    fn deserialize_f32<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
258    where
259        V: serde::de::Visitor<'de>,
260    {
261        visitor.visit_f32(Decode::decode(&mut self.de)?)
262    }
263
264    fn deserialize_f64<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
265    where
266        V: serde::de::Visitor<'de>,
267    {
268        visitor.visit_f64(Decode::decode(&mut self.de)?)
269    }
270
271    fn deserialize_char<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
272    where
273        V: serde::de::Visitor<'de>,
274    {
275        visitor.visit_char(Decode::decode(&mut self.de)?)
276    }
277
278    #[cfg(feature = "alloc")]
279    fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
280    where
281        V: serde::de::Visitor<'de>,
282    {
283        visitor.visit_string(P::decode(self.de)?)
284    }
285
286    #[cfg(not(feature = "alloc"))]
287    fn deserialize_str<V>(self, _: V) -> Result<V::Value, Self::Error>
288    where
289        V: serde::de::Visitor<'de>,
290    {
291        Err(SerdeDecodeError::CannotBorrowOwnedData.into())
292    }
293
294    #[cfg(feature = "alloc")]
295    fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
296    where
297        V: serde::de::Visitor<'de>,
298    {
299        visitor.visit_string(P::decode(self.de)?)
300    }
301
302    #[cfg(not(feature = "alloc"))]
303    fn deserialize_string<V>(self, _: V) -> Result<V::Value, Self::Error>
304    where
305        V: serde::de::Visitor<'de>,
306    {
307        Err(SerdeDecodeError::CannotAllocate.into())
308    }
309
310    #[cfg(feature = "alloc")]
311    fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
312    where
313        V: serde::de::Visitor<'de>,
314    {
315        visitor.visit_byte_buf(P::decode(self.de)?)
316    }
317
318    #[cfg(not(feature = "alloc"))]
319    fn deserialize_bytes<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
320    where
321        V: serde::de::Visitor<'de>,
322    {
323        Err(SerdeDecodeError::CannotBorrowOwnedData.into())
324    }
325
326    #[cfg(feature = "alloc")]
327    fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
328    where
329        V: serde::de::Visitor<'de>,
330    {
331        visitor.visit_byte_buf(P::decode(self.de)?)
332    }
333    #[cfg(not(feature = "alloc"))]
334    fn deserialize_byte_buf<V>(self, _: V) -> Result<V::Value, Self::Error>
335    where
336        V: serde::de::Visitor<'de>,
337    {
338        Err(SerdeDecodeError::CannotAllocate.into())
339    }
340
341    fn deserialize_option<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
342    where
343        V: serde::de::Visitor<'de>,
344    {
345        let variant = crate::de::decode_option_variant(&mut self.de, "Option<T>")?;
346        if variant.is_some() {
347            visitor.visit_some(self)
348        } else {
349            visitor.visit_none()
350        }
351    }
352
353    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
354    where
355        V: serde::de::Visitor<'de>,
356    {
357        visitor.visit_unit()
358    }
359
360    fn deserialize_unit_struct<V>(
361        self,
362        _name: &'static str,
363        visitor: V,
364    ) -> Result<V::Value, Self::Error>
365    where
366        V: serde::de::Visitor<'de>,
367    {
368        visitor.visit_unit()
369    }
370
371    fn deserialize_newtype_struct<V>(
372        self,
373        _name: &'static str,
374        visitor: V,
375    ) -> Result<V::Value, Self::Error>
376    where
377        V: serde::de::Visitor<'de>,
378    {
379        visitor.visit_newtype_struct(self)
380    }
381
382    fn deserialize_seq<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
383    where
384        V: serde::de::Visitor<'de>,
385    {
386        let len = usize::decode(&mut self.de)?;
387        self.deserialize_tuple(len, visitor)
388    }
389
390    fn deserialize_tuple<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
391    where
392        V: serde::de::Visitor<'de>,
393    {
394        struct Access<'a, 'b, DE: Decoder, P: Policy<DE>> {
395            deserializer: &'a mut SerdeDecoder<'b, DE, P>,
396            len: usize,
397        }
398
399        impl<'de, 'a, 'b: 'a, DE: Decoder + 'b, P: Policy<DE> + 'b> SeqAccess<'de>
400            for Access<'a, 'b, DE, P>
401        {
402            type Error = DecodeError;
403
404            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, DecodeError>
405            where
406                T: DeserializeSeed<'de>,
407            {
408                if self.len > 0 {
409                    self.len -= 1;
410                    let value = DeserializeSeed::deserialize(
411                        seed,
412                        SerdeDecoder {
413                            de: self.deserializer.de,
414                            policy: self.deserializer.policy,
415                        },
416                    )?;
417                    Ok(Some(value))
418                } else {
419                    Ok(None)
420                }
421            }
422
423            fn size_hint(&self) -> Option<usize> {
424                P::size_hint(self.len)
425            }
426        }
427
428        visitor.visit_seq(Access {
429            deserializer: &mut self,
430            len,
431        })
432    }
433
434    fn deserialize_tuple_struct<V>(
435        self,
436        _name: &'static str,
437        len: usize,
438        visitor: V,
439    ) -> Result<V::Value, Self::Error>
440    where
441        V: serde::de::Visitor<'de>,
442    {
443        self.deserialize_tuple(len, visitor)
444    }
445
446    fn deserialize_map<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
447    where
448        V: serde::de::Visitor<'de>,
449    {
450        struct Access<'a, 'b, DE: Decoder, P: Policy<DE>> {
451            deserializer: &'a mut SerdeDecoder<'b, DE, P>,
452            len: usize,
453        }
454
455        impl<'de, 'a, 'b: 'a, DE: Decoder + 'b, P: Policy<DE> + 'b> MapAccess<'de>
456            for Access<'a, 'b, DE, P>
457        {
458            type Error = DecodeError;
459
460            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, DecodeError>
461            where
462                K: DeserializeSeed<'de>,
463            {
464                if self.len > 0 {
465                    self.len -= 1;
466                    let key = DeserializeSeed::deserialize(
467                        seed,
468                        SerdeDecoder {
469                            de: self.deserializer.de,
470                            policy: self.deserializer.policy,
471                        },
472                    )?;
473                    Ok(Some(key))
474                } else {
475                    Ok(None)
476                }
477            }
478
479            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, DecodeError>
480            where
481                V: DeserializeSeed<'de>,
482            {
483                let value = DeserializeSeed::deserialize(
484                    seed,
485                    SerdeDecoder {
486                        de: self.deserializer.de,
487                        policy: self.deserializer.policy,
488                    },
489                )?;
490                Ok(value)
491            }
492
493            fn size_hint(&self) -> Option<usize> {
494                P::size_hint(self.len)
495            }
496        }
497
498        let len = usize::decode(&mut self.de)?;
499
500        visitor.visit_map(Access {
501            deserializer: &mut self,
502            len,
503        })
504    }
505
506    fn deserialize_struct<V>(
507        self,
508        _name: &'static str,
509        fields: &'static [&'static str],
510        visitor: V,
511    ) -> Result<V::Value, Self::Error>
512    where
513        V: serde::de::Visitor<'de>,
514    {
515        self.deserialize_tuple(fields.len(), visitor)
516    }
517
518    fn deserialize_enum<V>(
519        self,
520        _name: &'static str,
521        _variants: &'static [&'static str],
522        visitor: V,
523    ) -> Result<V::Value, Self::Error>
524    where
525        V: serde::de::Visitor<'de>,
526    {
527        visitor.visit_enum(self)
528    }
529
530    fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
531    where
532        V: serde::de::Visitor<'de>,
533    {
534        Err(SerdeDecodeError::IdentifierNotSupported.into())
535    }
536
537    fn deserialize_ignored_any<V>(self, _: V) -> Result<V::Value, Self::Error>
538    where
539        V: serde::de::Visitor<'de>,
540    {
541        Err(SerdeDecodeError::IgnoredAnyNotSupported.into())
542    }
543
544    fn is_human_readable(&self) -> bool {
545        false
546    }
547}
548
549impl<'de, DE: Decoder, P: Policy<DE>> EnumAccess<'de> for SerdeDecoder<'_, DE, P> {
550    type Error = DecodeError;
551    type Variant = Self;
552
553    fn variant_seed<V>(mut self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
554    where
555        V: DeserializeSeed<'de>,
556    {
557        let idx = u32::decode(&mut self.de)?;
558        let val = seed.deserialize(idx.into_deserializer())?;
559        Ok((val, self))
560    }
561}
562
563impl<'de, DE: Decoder, P: Policy<DE>> VariantAccess<'de> for SerdeDecoder<'_, DE, P> {
564    type Error = DecodeError;
565
566    fn unit_variant(self) -> Result<(), Self::Error> {
567        Ok(())
568    }
569
570    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
571    where
572        T: DeserializeSeed<'de>,
573    {
574        DeserializeSeed::deserialize(seed, self)
575    }
576
577    fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
578    where
579        V: Visitor<'de>,
580    {
581        Deserializer::deserialize_tuple(self, len, visitor)
582    }
583
584    fn struct_variant<V>(
585        self,
586        fields: &'static [&'static str],
587        visitor: V,
588    ) -> Result<V::Value, Self::Error>
589    where
590        V: Visitor<'de>,
591    {
592        Deserializer::deserialize_tuple(self, fields.len(), visitor)
593    }
594}
595
596/// An untrusted Serde decoder exposing only explicitly opted-in values.
597///
598/// Unlike the ordinary decoder this does not expose an unrestricted Serde deserializer.
599/// ```compile_fail
600/// let reader = bincode::de::read::SliceReader::new(&[1]);
601/// let mut decoder = bincode::serde::OwnedSerdeDecoder::from_reader_untrusted(reader, bincode::config::standard());
602/// let _ = decoder.as_deserializer();
603/// ```
604pub struct OwnedUntrustedSerdeDecoder<DE: UntrustedDecoder> {
605    inner: OwnedSerdeDecoder<DE>,
606}
607impl<DE: UntrustedDecoder> OwnedUntrustedSerdeDecoder<DE> {
608    /// Decode a value whose complete Serde graph explicitly opts in.
609    pub fn decode<T: for<'de> DeserializeUntrusted<'de>>(&mut self) -> Result<T, DecodeError> {
610        T::deserialize(SerdeDecoder {
611            de: &mut self.inner.de,
612            policy: Untrusted,
613        })
614    }
615}
bincode/features/serde/de_owned.rs

bincode/features/serde/
de_owned.rs
