1use config::{BincodeByteOrder, Options};
2use std::io::Read;
3
4use self::read::{BincodeRead, IoReader, SliceReader};
5use byteorder::ReadBytesExt;
6use config::{IntEncoding, SizeLimit};
7use serde;
8use serde::de::Error as DeError;
9use serde::de::IntoDeserializer;
10use {Error, ErrorKind, Result};
11
12/// Specialized ways to read data into bincode.
13pub mod read;
14
15/// A Deserializer that reads bytes from a buffer.
16///
17/// This struct should rarely be used.
18/// In most cases, prefer the `deserialize_from` function.
19///
20/// The ByteOrder that is chosen will impact the endianness that
21/// is used to read integers out of the reader.
22///
23/// ```ignore
24/// let d = Deserializer::new(&mut some_reader, SizeLimit::new());
25/// serde::Deserialize::deserialize(&mut deserializer);
26/// let bytes_read = d.bytes_read();
27/// ```
28pub struct Deserializer<R, O: Options> {
29 pub(crate) reader: R,
30 options: O,
31}
32
33macro_rules! impl_deserialize_literal {
34 ($name:ident : $ty:ty = $read:ident()) => {
35 #[inline]
36 pub(crate) fn $name(&mut self) -> Result<$ty> {
37 self.read_literal_type::<$ty>()?;
38 self.reader
39 .$read::<<O::Endian as BincodeByteOrder>::Endian>()
40 .map_err(Into::into)
41 }
42 };
43}
44
45impl<'de, IR: Read, O: Options> Deserializer<IoReader<IR>, O> {
46 /// Creates a new Deserializer with a given `Read`er and options.
47 pub fn with_reader(r: IR, options: O) -> Self {
48 Deserializer {
49 reader: IoReader::new(r),
50 options,
51 }
52 }
53}
54
55impl<'de, O: Options> Deserializer<SliceReader<'de>, O> {
56 /// Creates a new Deserializer that will read from the given slice.
57 pub fn from_slice(slice: &'de [u8], options: O) -> Self {
58 Deserializer {
59 reader: SliceReader::new(bytes:slice),
60 options,
61 }
62 }
63}
64
65impl<'de, R: BincodeRead<'de>, O: Options> Deserializer<R, O> {
66 /// Creates a new Deserializer with the given `BincodeRead`er
67 pub fn with_bincode_read(r: R, options: O) -> Deserializer<R, O> {
68 Deserializer { reader: r, options }
69 }
70
71 pub(crate) fn deserialize_byte(&mut self) -> Result<u8> {
72 self.read_literal_type::<u8>()?;
73 self.reader.read_u8().map_err(Into::into)
74 }
75
76 impl_deserialize_literal! { deserialize_literal_u16 : u16 = read_u16() }
77 impl_deserialize_literal! { deserialize_literal_u32 : u32 = read_u32() }
78 impl_deserialize_literal! { deserialize_literal_u64 : u64 = read_u64() }
79
80 serde_if_integer128! {
81 impl_deserialize_literal! { deserialize_literal_u128 : u128 = read_u128() }
82 }
83
84 fn read_bytes(&mut self, count: u64) -> Result<()> {
85 self.options.limit().add(count)
86 }
87
88 fn read_literal_type<T>(&mut self) -> Result<()> {
89 use std::mem::size_of;
90 self.read_bytes(size_of::<T>() as u64)
91 }
92
93 fn read_vec(&mut self) -> Result<Vec<u8>> {
94 let len = O::IntEncoding::deserialize_len(self)?;
95 self.read_bytes(len as u64)?;
96 self.reader.get_byte_buffer(len)
97 }
98
99 fn read_string(&mut self) -> Result<String> {
100 let vec = self.read_vec()?;
101 String::from_utf8(vec).map_err(|e| ErrorKind::InvalidUtf8Encoding(e.utf8_error()).into())
102 }
103}
104
105macro_rules! impl_deserialize_int {
106 ($name:ident = $visitor_method:ident ($dser_method:ident)) => {
107 #[inline]
108 fn $name<V>(self, visitor: V) -> Result<V::Value>
109 where
110 V: serde::de::Visitor<'de>,
111 {
112 visitor.$visitor_method(O::IntEncoding::$dser_method(self)?)
113 }
114 };
115}
116
117impl<'de, 'a, R, O> serde::Deserializer<'de> for &'a mut Deserializer<R, O>
118where
119 R: BincodeRead<'de>,
120 O: Options,
121{
122 type Error = Error;
123
124 #[inline]
125 fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value>
126 where
127 V: serde::de::Visitor<'de>,
128 {
129 Err(Box::new(ErrorKind::DeserializeAnyNotSupported))
130 }
131
132 fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value>
133 where
134 V: serde::de::Visitor<'de>,
135 {
136 match self.deserialize_byte()? {
137 1 => visitor.visit_bool(true),
138 0 => visitor.visit_bool(false),
139 value => Err(ErrorKind::InvalidBoolEncoding(value).into()),
140 }
141 }
142
143 impl_deserialize_int!(deserialize_u16 = visit_u16(deserialize_u16));
144 impl_deserialize_int!(deserialize_u32 = visit_u32(deserialize_u32));
145 impl_deserialize_int!(deserialize_u64 = visit_u64(deserialize_u64));
146 impl_deserialize_int!(deserialize_i16 = visit_i16(deserialize_i16));
147 impl_deserialize_int!(deserialize_i32 = visit_i32(deserialize_i32));
148 impl_deserialize_int!(deserialize_i64 = visit_i64(deserialize_i64));
149
150 fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value>
151 where
152 V: serde::de::Visitor<'de>,
153 {
154 self.read_literal_type::<f32>()?;
155 let value = self
156 .reader
157 .read_f32::<<O::Endian as BincodeByteOrder>::Endian>()?;
158 visitor.visit_f32(value)
159 }
160
161 fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value>
162 where
163 V: serde::de::Visitor<'de>,
164 {
165 self.read_literal_type::<f64>()?;
166 let value = self
167 .reader
168 .read_f64::<<O::Endian as BincodeByteOrder>::Endian>()?;
169 visitor.visit_f64(value)
170 }
171
172 serde_if_integer128! {
173 impl_deserialize_int!(deserialize_u128 = visit_u128(deserialize_u128));
174 impl_deserialize_int!(deserialize_i128 = visit_i128(deserialize_i128));
175 }
176
177 #[inline]
178 fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value>
179 where
180 V: serde::de::Visitor<'de>,
181 {
182 visitor.visit_u8(self.deserialize_byte()? as u8)
183 }
184
185 #[inline]
186 fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value>
187 where
188 V: serde::de::Visitor<'de>,
189 {
190 visitor.visit_i8(self.deserialize_byte()? as i8)
191 }
192
193 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
194 where
195 V: serde::de::Visitor<'de>,
196 {
197 visitor.visit_unit()
198 }
199
200 fn deserialize_char<V>(self, visitor: V) -> Result<V::Value>
201 where
202 V: serde::de::Visitor<'de>,
203 {
204 use std::str;
205
206 let error = || ErrorKind::InvalidCharEncoding.into();
207
208 let mut buf = [0u8; 4];
209
210 // Look at the first byte to see how many bytes must be read
211 self.reader.read_exact(&mut buf[..1])?;
212 let width = utf8_char_width(buf[0]);
213 if width == 1 {
214 return visitor.visit_char(buf[0] as char);
215 }
216 if width == 0 {
217 return Err(error());
218 }
219
220 if self.reader.read_exact(&mut buf[1..width]).is_err() {
221 return Err(error());
222 }
223
224 let res = str::from_utf8(&buf[..width])
225 .ok()
226 .and_then(|s| s.chars().next())
227 .ok_or_else(error)?;
228 visitor.visit_char(res)
229 }
230
231 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
232 where
233 V: serde::de::Visitor<'de>,
234 {
235 let len = O::IntEncoding::deserialize_len(self)?;
236 self.read_bytes(len as u64)?;
237 self.reader.forward_read_str(len, visitor)
238 }
239
240 fn deserialize_string<V>(self, visitor: V) -> Result<V::Value>
241 where
242 V: serde::de::Visitor<'de>,
243 {
244 visitor.visit_string(self.read_string()?)
245 }
246
247 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
248 where
249 V: serde::de::Visitor<'de>,
250 {
251 let len = O::IntEncoding::deserialize_len(self)?;
252 self.read_bytes(len as u64)?;
253 self.reader.forward_read_bytes(len, visitor)
254 }
255
256 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
257 where
258 V: serde::de::Visitor<'de>,
259 {
260 visitor.visit_byte_buf(self.read_vec()?)
261 }
262
263 fn deserialize_enum<V>(
264 self,
265 _enum: &'static str,
266 _variants: &'static [&'static str],
267 visitor: V,
268 ) -> Result<V::Value>
269 where
270 V: serde::de::Visitor<'de>,
271 {
272 impl<'de, 'a, R: 'a, O> serde::de::EnumAccess<'de> for &'a mut Deserializer<R, O>
273 where
274 R: BincodeRead<'de>,
275 O: Options,
276 {
277 type Error = Error;
278 type Variant = Self;
279
280 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
281 where
282 V: serde::de::DeserializeSeed<'de>,
283 {
284 let idx: u32 = O::IntEncoding::deserialize_u32(self)?;
285 let val: Result<_> = seed.deserialize(idx.into_deserializer());
286 Ok((val?, self))
287 }
288 }
289
290 visitor.visit_enum(self)
291 }
292
293 fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value>
294 where
295 V: serde::de::Visitor<'de>,
296 {
297 struct Access<'a, R: Read + 'a, O: Options + 'a> {
298 deserializer: &'a mut Deserializer<R, O>,
299 len: usize,
300 }
301
302 impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options> serde::de::SeqAccess<'de>
303 for Access<'a, R, O>
304 {
305 type Error = Error;
306
307 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
308 where
309 T: serde::de::DeserializeSeed<'de>,
310 {
311 if self.len > 0 {
312 self.len -= 1;
313 let value =
314 serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
315 Ok(Some(value))
316 } else {
317 Ok(None)
318 }
319 }
320
321 fn size_hint(&self) -> Option<usize> {
322 Some(self.len)
323 }
324 }
325
326 visitor.visit_seq(Access {
327 deserializer: self,
328 len,
329 })
330 }
331
332 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
333 where
334 V: serde::de::Visitor<'de>,
335 {
336 let value: u8 = serde::de::Deserialize::deserialize(&mut *self)?;
337 match value {
338 0 => visitor.visit_none(),
339 1 => visitor.visit_some(&mut *self),
340 v => Err(ErrorKind::InvalidTagEncoding(v as usize).into()),
341 }
342 }
343
344 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
345 where
346 V: serde::de::Visitor<'de>,
347 {
348 let len = O::IntEncoding::deserialize_len(self)?;
349
350 self.deserialize_tuple(len, visitor)
351 }
352
353 fn deserialize_map<V>(self, visitor: V) -> Result<V::Value>
354 where
355 V: serde::de::Visitor<'de>,
356 {
357 struct Access<'a, R: Read + 'a, O: Options + 'a> {
358 deserializer: &'a mut Deserializer<R, O>,
359 len: usize,
360 }
361
362 impl<'de, 'a, 'b: 'a, R: BincodeRead<'de> + 'b, O: Options> serde::de::MapAccess<'de>
363 for Access<'a, R, O>
364 {
365 type Error = Error;
366
367 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
368 where
369 K: serde::de::DeserializeSeed<'de>,
370 {
371 if self.len > 0 {
372 self.len -= 1;
373 let key =
374 serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
375 Ok(Some(key))
376 } else {
377 Ok(None)
378 }
379 }
380
381 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
382 where
383 V: serde::de::DeserializeSeed<'de>,
384 {
385 let value = serde::de::DeserializeSeed::deserialize(seed, &mut *self.deserializer)?;
386 Ok(value)
387 }
388
389 fn size_hint(&self) -> Option<usize> {
390 Some(self.len)
391 }
392 }
393
394 let len = O::IntEncoding::deserialize_len(self)?;
395
396 visitor.visit_map(Access {
397 deserializer: self,
398 len,
399 })
400 }
401
402 fn deserialize_struct<V>(
403 self,
404 _name: &str,
405 fields: &'static [&'static str],
406 visitor: V,
407 ) -> Result<V::Value>
408 where
409 V: serde::de::Visitor<'de>,
410 {
411 self.deserialize_tuple(fields.len(), visitor)
412 }
413
414 fn deserialize_identifier<V>(self, _visitor: V) -> Result<V::Value>
415 where
416 V: serde::de::Visitor<'de>,
417 {
418 let message = "Bincode does not support Deserializer::deserialize_identifier";
419 Err(Error::custom(message))
420 }
421
422 fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value>
423 where
424 V: serde::de::Visitor<'de>,
425 {
426 visitor.visit_newtype_struct(self)
427 }
428
429 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
430 where
431 V: serde::de::Visitor<'de>,
432 {
433 visitor.visit_unit()
434 }
435
436 fn deserialize_tuple_struct<V>(
437 self,
438 _name: &'static str,
439 len: usize,
440 visitor: V,
441 ) -> Result<V::Value>
442 where
443 V: serde::de::Visitor<'de>,
444 {
445 self.deserialize_tuple(len, visitor)
446 }
447
448 fn deserialize_ignored_any<V>(self, _visitor: V) -> Result<V::Value>
449 where
450 V: serde::de::Visitor<'de>,
451 {
452 let message = "Bincode does not support Deserializer::deserialize_ignored_any";
453 Err(Error::custom(message))
454 }
455
456 fn is_human_readable(&self) -> bool {
457 false
458 }
459}
460
461impl<'de, 'a, R, O> serde::de::VariantAccess<'de> for &'a mut Deserializer<R, O>
462where
463 R: BincodeRead<'de>,
464 O: Options,
465{
466 type Error = Error;
467
468 fn unit_variant(self) -> Result<()> {
469 Ok(())
470 }
471
472 fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value>
473 where
474 T: serde::de::DeserializeSeed<'de>,
475 {
476 serde::de::DeserializeSeed::deserialize(seed, self)
477 }
478
479 fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value>
480 where
481 V: serde::de::Visitor<'de>,
482 {
483 serde::de::Deserializer::deserialize_tuple(self, len, visitor)
484 }
485
486 fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value>
487 where
488 V: serde::de::Visitor<'de>,
489 {
490 serde::de::Deserializer::deserialize_tuple(self, fields.len(), visitor)
491 }
492}
493static UTF8_CHAR_WIDTH: [u8; 256] = [
494 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
495 1, // 0x1F
496 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
497 1, // 0x3F
498 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
499 1, // 0x5F
500 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
501 1, // 0x7F
502 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
503 0, // 0x9F
504 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
505 0, // 0xBF
506 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2,
507 2, // 0xDF
508 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, // 0xEF
509 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, // 0xFF
510];
511
512// This function is a copy of core::str::utf8_char_width
513fn utf8_char_width(b: u8) -> usize {
514 UTF8_CHAR_WIDTH[b as usize] as usize
515}
516