1 use core::convert::TryFrom;
2
3 use serde::de::{self, DeserializeSeed, EnumAccess, MapAccess, SeqAccess, Visitor};
4 use static_assertions::assert_impl_all;
5
6 use std::{ffi::CStr, marker::PhantomData, os::unix::io::RawFd, str};
7
8 use crate::{
9 de::ValueParseStage, framing_offset_size::FramingOffsetSize, framing_offsets::FramingOffsets,
10 signature_parser::SignatureParser, utils::*, EncodingContext, EncodingFormat, Error, Result,
11 Signature,
12 };
13
14 /// Our GVariant deserialization implementation.
15 #[derive(Debug)]
16 pub struct Deserializer<'de, 'sig, 'f, B>(pub(crate) crate::DeserializerCommon<'de, 'sig, 'f, B>);
17
18 assert_impl_all!(Deserializer<'_, '_,'_, i32>: Send, Sync, Unpin);
19
20 impl<'de, 'sig, 'f, B> Deserializer<'de, 'sig, 'f, B>
21 where
22 B: byteorder::ByteOrder,
23 {
24 /// Create a Deserializer struct instance.
new<'r: 'de>( bytes: &'r [u8], fds: Option<&'f [RawFd]>, signature: &Signature<'sig>, ctxt: EncodingContext<B>, ) -> Self25 pub fn new<'r: 'de>(
26 bytes: &'r [u8],
27 fds: Option<&'f [RawFd]>,
28 signature: &Signature<'sig>,
29 ctxt: EncodingContext<B>,
30 ) -> Self {
31 assert_eq!(ctxt.format(), EncodingFormat::GVariant);
32
33 let sig_parser = SignatureParser::new(signature.clone());
34 Self(crate::DeserializerCommon {
35 ctxt,
36 sig_parser,
37 bytes,
38 fds,
39 pos: 0,
40 b: PhantomData,
41 })
42 }
43 }
44
45 macro_rules! deserialize_basic {
46 ($method:ident) => {
47 #[inline]
48 fn $method<V>(self, visitor: V) -> Result<V::Value>
49 where
50 V: Visitor<'de>,
51 {
52 let ctxt = EncodingContext::new_dbus(self.0.ctxt.position() + self.0.pos);
53
54 let mut dbus_de = crate::dbus::Deserializer::<B>(crate::DeserializerCommon::<B> {
55 ctxt,
56 sig_parser: self.0.sig_parser.clone(),
57 bytes: &self.0.bytes[self.0.pos..],
58 fds: self.0.fds,
59 pos: 0,
60 b: PhantomData,
61 });
62
63 let v = dbus_de.$method(visitor)?;
64 self.0.sig_parser = dbus_de.0.sig_parser;
65 self.0.pos += dbus_de.0.pos;
66
67 Ok(v)
68 }
69 };
70 }
71
72 macro_rules! deserialize_as {
73 ($method:ident => $as:ident) => {
74 deserialize_as!($method() => $as());
75 };
76 ($method:ident($($in_arg:ident: $type:ty),*) => $as:ident($($as_arg:expr),*)) => {
77 #[inline]
78 fn $method<V>(self, $($in_arg: $type,)* visitor: V) -> Result<V::Value>
79 where
80 V: Visitor<'de>,
81 {
82 self.$as($($as_arg,)* visitor)
83 }
84 }
85 }
86
87 impl<'de, 'd, 'sig, 'f, B> de::Deserializer<'de> for &'d mut Deserializer<'de, 'sig, 'f, B>
88 where
89 B: byteorder::ByteOrder,
90 {
91 type Error = Error;
92
deserialize_any<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,93 fn deserialize_any<V>(self, visitor: V) -> Result<V::Value>
94 where
95 V: Visitor<'de>,
96 {
97 let c = self.0.sig_parser.next_char();
98
99 crate::de::deserialize_any::<B, Self, V>(self, c, visitor)
100 }
101
102 deserialize_basic!(deserialize_bool);
103 deserialize_basic!(deserialize_i8);
104 deserialize_basic!(deserialize_i16);
105 deserialize_basic!(deserialize_i32);
106 deserialize_basic!(deserialize_i64);
107 deserialize_basic!(deserialize_u8);
108 deserialize_basic!(deserialize_u16);
109 deserialize_basic!(deserialize_u32);
110 deserialize_basic!(deserialize_u64);
111 deserialize_basic!(deserialize_f32);
112 deserialize_basic!(deserialize_f64);
113 deserialize_basic!(deserialize_identifier);
114
deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,115 fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value>
116 where
117 V: Visitor<'de>,
118 {
119 let bytes = deserialize_ay(self)?;
120 visitor.visit_byte_buf(bytes.into())
121 }
122
deserialize_bytes<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,123 fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value>
124 where
125 V: Visitor<'de>,
126 {
127 let bytes = deserialize_ay(self)?;
128 visitor.visit_borrowed_bytes(bytes)
129 }
130
131 deserialize_as!(deserialize_char => deserialize_str);
132 deserialize_as!(deserialize_string => deserialize_str);
133 deserialize_as!(deserialize_tuple(_l: usize) => deserialize_struct("", &[]));
134 deserialize_as!(deserialize_tuple_struct(n: &'static str, _l: usize) => deserialize_struct(n, &[]));
135 deserialize_as!(deserialize_struct(_n: &'static str, _f: &'static [&'static str]) => deserialize_seq());
136 deserialize_as!(deserialize_map => deserialize_seq);
137 deserialize_as!(deserialize_ignored_any => deserialize_any);
138
deserialize_str<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,139 fn deserialize_str<V>(self, visitor: V) -> Result<V::Value>
140 where
141 V: Visitor<'de>,
142 {
143 let s = if self.0.sig_parser.next_char() == VARIANT_SIGNATURE_CHAR {
144 let slice = &self.0.bytes[self.0.pos..];
145
146 if slice.contains(&0) {
147 return Err(serde::de::Error::invalid_value(
148 serde::de::Unexpected::Char('\0'),
149 &"GVariant string type must not contain interior null bytes",
150 ));
151 }
152
153 // GVariant decided to skip the trailing nul at the end of signature string
154 str::from_utf8(slice).map_err(Error::Utf8)?
155 } else {
156 let cstr =
157 CStr::from_bytes_with_nul(&self.0.bytes[self.0.pos..]).map_err(|_| -> Error {
158 let c = self.0.bytes[self.0.bytes.len() - 1] as char;
159 de::Error::invalid_value(
160 de::Unexpected::Char(c),
161 &"nul byte expected at the end of strings",
162 )
163 })?;
164 let s = cstr.to_str().map_err(Error::Utf8)?;
165 self.0.pos += s.len() + 1; // string and trailing null byte
166
167 s
168 };
169 self.0.sig_parser.skip_char()?;
170
171 visitor.visit_borrowed_str(s)
172 }
173
deserialize_option<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,174 fn deserialize_option<V>(self, visitor: V) -> Result<V::Value>
175 where
176 V: Visitor<'de>,
177 {
178 let signature = self.0.sig_parser.next_signature()?;
179 let alignment = alignment_for_signature(&signature, self.0.ctxt.format());
180 let child_sig_parser = self.0.sig_parser.slice(1..);
181 let child_signature = child_sig_parser.next_signature()?;
182 let child_sig_len = child_signature.len();
183 let fixed_sized_child = crate::utils::is_fixed_sized_signature(&child_signature)?;
184
185 self.0.sig_parser.skip_char()?;
186 self.0.parse_padding(alignment)?;
187
188 if self.0.pos == self.0.bytes.len() {
189 // Empty sequence means None
190 self.0.sig_parser.skip_chars(child_sig_len)?;
191
192 visitor.visit_none()
193 } else {
194 let ctxt =
195 EncodingContext::new(self.0.ctxt.format(), self.0.ctxt.position() + self.0.pos);
196 let end = if fixed_sized_child {
197 self.0.bytes.len()
198 } else {
199 self.0.bytes.len() - 1
200 };
201
202 let mut de = Deserializer::<B>(crate::DeserializerCommon {
203 ctxt,
204 sig_parser: self.0.sig_parser.clone(),
205 bytes: &self.0.bytes[self.0.pos..end],
206 fds: self.0.fds,
207 pos: 0,
208 b: PhantomData,
209 });
210
211 let v = visitor.visit_some(&mut de)?;
212 self.0.pos += de.0.pos;
213
214 if !fixed_sized_child {
215 let byte = self.0.bytes[self.0.pos];
216 if byte != 0 {
217 return Err(de::Error::invalid_value(
218 de::Unexpected::Bytes(&byte.to_le_bytes()),
219 &"0 byte expected at end of Maybe value",
220 ));
221 }
222
223 self.0.pos += 1;
224 }
225 self.0.sig_parser = de.0.sig_parser;
226
227 Ok(v)
228 }
229 }
230
deserialize_unit<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,231 fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value>
232 where
233 V: Visitor<'de>,
234 {
235 let byte = self.0.bytes[self.0.pos];
236 if byte != 0 {
237 return Err(de::Error::invalid_value(
238 de::Unexpected::Bytes(&self.0.bytes[self.0.pos..self.0.pos + 1]),
239 &"0 byte expected for empty tuples (unit type)",
240 ));
241 }
242
243 self.0.pos += 1;
244
245 visitor.visit_unit()
246 }
247
deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value> where V: Visitor<'de>,248 fn deserialize_unit_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
249 where
250 V: Visitor<'de>,
251 {
252 visitor.visit_unit()
253 }
254
deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value> where V: Visitor<'de>,255 fn deserialize_newtype_struct<V>(self, _name: &'static str, visitor: V) -> Result<V::Value>
256 where
257 V: Visitor<'de>,
258 {
259 visitor.visit_newtype_struct(self)
260 }
261
deserialize_seq<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de>,262 fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value>
263 where
264 V: Visitor<'de>,
265 {
266 match self.0.sig_parser.next_char() {
267 VARIANT_SIGNATURE_CHAR => {
268 self.0.sig_parser.skip_char()?;
269 self.0.parse_padding(VARIANT_ALIGNMENT_GVARIANT)?;
270 let value_de = ValueDeserializer::new(self)?;
271
272 visitor.visit_seq(value_de)
273 }
274 ARRAY_SIGNATURE_CHAR => {
275 self.0.sig_parser.skip_char()?;
276 let next_signature_char = self.0.sig_parser.next_char();
277 let array_de = ArrayDeserializer::new(self)?;
278
279 if next_signature_char == DICT_ENTRY_SIG_START_CHAR {
280 visitor.visit_map(array_de)
281 } else {
282 visitor.visit_seq(array_de)
283 }
284 }
285 STRUCT_SIG_START_CHAR => {
286 let signature = self.0.sig_parser.next_signature()?;
287 let alignment = alignment_for_signature(&signature, self.0.ctxt.format());
288 self.0.parse_padding(alignment)?;
289
290 self.0.sig_parser.skip_char()?;
291
292 let start = self.0.pos;
293 let end = self.0.bytes.len();
294 let offset_size = FramingOffsetSize::for_encoded_container(end - start);
295 visitor.visit_seq(StructureDeserializer {
296 de: self,
297 start,
298 end,
299 offsets_len: 0,
300 offset_size,
301 })
302 }
303 c => Err(de::Error::invalid_type(
304 de::Unexpected::Char(c),
305 &format!(
306 "`{}`, `{}` or `{}`",
307 VARIANT_SIGNATURE_CHAR, ARRAY_SIGNATURE_CHAR, STRUCT_SIG_START_CHAR,
308 )
309 .as_str(),
310 )),
311 }
312 }
313
deserialize_enum<V>( self, name: &'static str, _variants: &'static [&'static str], visitor: V, ) -> Result<V::Value> where V: Visitor<'de>,314 fn deserialize_enum<V>(
315 self,
316 name: &'static str,
317 _variants: &'static [&'static str],
318 visitor: V,
319 ) -> Result<V::Value>
320 where
321 V: Visitor<'de>,
322 {
323 visitor.visit_enum(crate::de::Enum {
324 de: self,
325 name,
326 phantom: PhantomData,
327 })
328 }
329 }
330
deserialize_ay<'de, 'sig, 'f, B>(de: &mut Deserializer<'de, 'sig, 'f, B>) -> Result<&'de [u8]> where B: byteorder::ByteOrder,331 fn deserialize_ay<'de, 'sig, 'f, B>(de: &mut Deserializer<'de, 'sig, 'f, B>) -> Result<&'de [u8]>
332 where
333 B: byteorder::ByteOrder,
334 {
335 if de.0.sig_parser.next_signature()? != "ay" {
336 return Err(de::Error::invalid_type(de::Unexpected::Seq, &"ay"));
337 }
338
339 de.0.sig_parser.skip_char()?;
340 let ad = ArrayDeserializer::new(de)?;
341 let len = dbg!(ad.len);
342 de.0.next_slice(len)
343 }
344
345 struct ArrayDeserializer<'d, 'de, 'sig, 'f, B> {
346 de: &'d mut Deserializer<'de, 'sig, 'f, B>,
347 len: usize,
348 start: usize,
349 // alignment of element
350 element_alignment: usize,
351 // where value signature starts
352 element_signature_len: usize,
353 // All offsets (GVariant-specific)
354 offsets: Option<FramingOffsets>,
355 // Length of all the offsets after the array
356 offsets_len: usize,
357 // size of the framing offset of last dict-entry key read (GVariant-specific)
358 key_offset_size: Option<FramingOffsetSize>,
359 }
360
361 impl<'d, 'de, 'sig, 'f, B> ArrayDeserializer<'d, 'de, 'sig, 'f, B>
362 where
363 B: byteorder::ByteOrder,
364 {
new(de: &'d mut Deserializer<'de, 'sig, 'f, B>) -> Result<Self>365 fn new(de: &'d mut Deserializer<'de, 'sig, 'f, B>) -> Result<Self> {
366 let mut len = de.0.bytes.len() - de.0.pos;
367
368 let element_signature = de.0.sig_parser.next_signature()?;
369 let element_alignment = alignment_for_signature(&element_signature, de.0.ctxt.format());
370 let element_signature_len = element_signature.len();
371 let fixed_sized_child = crate::utils::is_fixed_sized_signature(&element_signature)?;
372 let fixed_sized_key = if de.0.sig_parser.next_char() == DICT_ENTRY_SIG_START_CHAR {
373 // Key signature can only be 1 char
374 let key_signature = Signature::from_str_unchecked(&element_signature[1..2]);
375
376 crate::utils::is_fixed_sized_signature(&key_signature)?
377 } else {
378 false
379 };
380
381 // D-Bus requires padding for the first element even when there is no first element
382 // (i-e empty array) so we parse padding already. In case of GVariant this is just
383 // the padding of the array itself since array starts with first element.
384 let padding = de.0.parse_padding(element_alignment)?;
385 len -= padding;
386
387 let (offsets, offsets_len, key_offset_size) = if !fixed_sized_child {
388 let (array_offsets, offsets_len) =
389 FramingOffsets::from_encoded_array(&de.0.bytes[de.0.pos..]);
390 len -= offsets_len;
391 let key_offset_size = if !fixed_sized_key {
392 // The actual offset for keys is calculated per key later, this is just to
393 // put Some value to indicate at key is not fixed sized and thus uses
394 // offsets.
395 Some(FramingOffsetSize::U8)
396 } else {
397 None
398 };
399
400 (Some(array_offsets), offsets_len, key_offset_size)
401 } else {
402 (None, 0, None)
403 };
404 let start = de.0.pos;
405
406 if de.0.sig_parser.next_char() == DICT_ENTRY_SIG_START_CHAR {
407 de.0.sig_parser.skip_char()?;
408 }
409
410 Ok(Self {
411 de,
412 len,
413 start,
414 element_alignment,
415 element_signature_len,
416 offsets,
417 offsets_len,
418 key_offset_size,
419 })
420 }
421
element_end(&mut self, pop: bool) -> Result<usize>422 fn element_end(&mut self, pop: bool) -> Result<usize> {
423 match self.offsets.as_mut() {
424 Some(offsets) => {
425 assert_eq!(self.de.0.ctxt.format(), EncodingFormat::GVariant);
426
427 let offset = if pop { offsets.pop() } else { offsets.peek() };
428 match offset {
429 Some(offset) => Ok(self.start + offset),
430 None => Err(Error::MissingFramingOffset),
431 }
432 }
433 None => Ok(self.start + self.len),
434 }
435 }
436
done(&self) -> bool437 fn done(&self) -> bool {
438 match self.offsets.as_ref() {
439 // If all offsets have been popped/used, we're already at the end
440 Some(offsets) => offsets.is_empty(),
441 None => self.de.0.pos == self.start + self.len,
442 }
443 }
444 }
445
446 impl<'d, 'de, 'sig, 'f, B> SeqAccess<'de> for ArrayDeserializer<'d, 'de, 'sig, 'f, B>
447 where
448 B: byteorder::ByteOrder,
449 {
450 type Error = Error;
451
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> where T: DeserializeSeed<'de>,452 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
453 where
454 T: DeserializeSeed<'de>,
455 {
456 if self.done() {
457 self.de
458 .0
459 .sig_parser
460 .skip_chars(self.element_signature_len)?;
461 self.de.0.pos += self.offsets_len;
462
463 return Ok(None);
464 }
465
466 let ctxt = EncodingContext::new(
467 self.de.0.ctxt.format(),
468 self.de.0.ctxt.position() + self.de.0.pos,
469 );
470 let end = self.element_end(true)?;
471
472 let mut de = Deserializer::<B>(crate::DeserializerCommon {
473 ctxt,
474 sig_parser: self.de.0.sig_parser.clone(),
475 bytes: &self.de.0.bytes[self.de.0.pos..end],
476 fds: self.de.0.fds,
477 pos: 0,
478 b: PhantomData,
479 });
480
481 let v = seed.deserialize(&mut de).map(Some);
482 self.de.0.pos += de.0.pos;
483
484 if self.de.0.pos > self.start + self.len {
485 return Err(serde::de::Error::invalid_length(
486 self.len,
487 &format!(">= {}", self.de.0.pos - self.start).as_str(),
488 ));
489 }
490
491 v
492 }
493 }
494
495 impl<'d, 'de, 'sig, 'f, B> MapAccess<'de> for ArrayDeserializer<'d, 'de, 'sig, 'f, B>
496 where
497 B: byteorder::ByteOrder,
498 {
499 type Error = Error;
500
next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>> where K: DeserializeSeed<'de>,501 fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>>
502 where
503 K: DeserializeSeed<'de>,
504 {
505 if self.done() {
506 // Starting bracket was already skipped
507 self.de
508 .0
509 .sig_parser
510 .skip_chars(self.element_signature_len - 1)?;
511 self.de.0.pos += self.offsets_len;
512
513 return Ok(None);
514 }
515
516 self.de.0.parse_padding(self.element_alignment)?;
517
518 let ctxt = EncodingContext::new(
519 self.de.0.ctxt.format(),
520 self.de.0.ctxt.position() + self.de.0.pos,
521 );
522 let element_end = self.element_end(false)?;
523
524 let key_end = match self.key_offset_size {
525 Some(_) => {
526 let offset_size =
527 FramingOffsetSize::for_encoded_container(element_end - self.de.0.pos);
528 self.key_offset_size.replace(offset_size);
529
530 self.de.0.pos
531 + offset_size
532 .read_last_offset_from_buffer(&self.de.0.bytes[self.de.0.pos..element_end])
533 }
534 None => element_end,
535 };
536
537 let mut de = Deserializer::<B>(crate::DeserializerCommon {
538 ctxt,
539 sig_parser: self.de.0.sig_parser.clone(),
540 bytes: &self.de.0.bytes[self.de.0.pos..key_end],
541 fds: self.de.0.fds,
542 pos: 0,
543 b: PhantomData,
544 });
545 let v = seed.deserialize(&mut de).map(Some);
546 self.de.0.pos += de.0.pos;
547
548 if self.de.0.pos > self.start + self.len {
549 return Err(serde::de::Error::invalid_length(
550 self.len,
551 &format!(">= {}", self.de.0.pos - self.start).as_str(),
552 ));
553 }
554
555 v
556 }
557
next_value_seed<V>(&mut self, seed: V) -> Result<V::Value> where V: DeserializeSeed<'de>,558 fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value>
559 where
560 V: DeserializeSeed<'de>,
561 {
562 let ctxt = EncodingContext::new(
563 self.de.0.ctxt.format(),
564 self.de.0.ctxt.position() + self.de.0.pos,
565 );
566 let element_end = self.element_end(true)?;
567 let value_end = match self.key_offset_size {
568 Some(key_offset_size) => element_end - key_offset_size as usize,
569 None => element_end,
570 };
571 let mut sig_parser = self.de.0.sig_parser.clone();
572 // Skip key signature (always 1 char)
573 sig_parser.skip_char()?;
574
575 let mut de = Deserializer::<B>(crate::DeserializerCommon {
576 ctxt,
577 sig_parser,
578 bytes: &self.de.0.bytes[self.de.0.pos..value_end],
579 fds: self.de.0.fds,
580 pos: 0,
581 b: PhantomData,
582 });
583 let v = seed.deserialize(&mut de);
584 self.de.0.pos += de.0.pos;
585
586 if let Some(key_offset_size) = self.key_offset_size {
587 self.de.0.pos += key_offset_size as usize;
588 }
589
590 if self.de.0.pos > self.start + self.len {
591 return Err(serde::de::Error::invalid_length(
592 self.len,
593 &format!(">= {}", self.de.0.pos - self.start).as_str(),
594 ));
595 }
596
597 v
598 }
599 }
600
601 #[derive(Debug)]
602 struct StructureDeserializer<'d, 'de, 'sig, 'f, B> {
603 de: &'d mut Deserializer<'de, 'sig, 'f, B>,
604 start: usize,
605 end: usize,
606 // Length of all the offsets after the array
607 offsets_len: usize,
608 // size of the framing offset
609 offset_size: FramingOffsetSize,
610 }
611
612 impl<'d, 'de, 'sig, 'f, B> SeqAccess<'de> for StructureDeserializer<'d, 'de, 'sig, 'f, B>
613 where
614 B: byteorder::ByteOrder,
615 {
616 type Error = Error;
617
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> where T: DeserializeSeed<'de>,618 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
619 where
620 T: DeserializeSeed<'de>,
621 {
622 let ctxt = EncodingContext::new(
623 self.de.0.ctxt.format(),
624 self.de.0.ctxt.position() + self.de.0.pos,
625 );
626 let element_signature = self.de.0.sig_parser.next_signature()?;
627 let fixed_sized_element = crate::utils::is_fixed_sized_signature(&element_signature)?;
628 let element_end = if !fixed_sized_element {
629 let next_sig_pos = element_signature.len();
630 let parser = self.de.0.sig_parser.slice(next_sig_pos..);
631 if !parser.done() && parser.next_char() == STRUCT_SIG_END_CHAR {
632 // This is the last item then and in GVariant format, we don't have offset for it
633 // even if it's non-fixed-sized.
634 self.end
635 } else {
636 let end = self
637 .offset_size
638 .read_last_offset_from_buffer(&self.de.0.bytes[self.start..self.end])
639 + self.start;
640 self.end -= self.offset_size as usize;
641 self.offsets_len += self.offset_size as usize;
642
643 end
644 }
645 } else {
646 self.end
647 };
648
649 let sig_parser = self.de.0.sig_parser.clone();
650 let mut de = Deserializer::<B>(crate::DeserializerCommon {
651 ctxt,
652 sig_parser,
653 bytes: &self.de.0.bytes[self.de.0.pos..element_end],
654 fds: self.de.0.fds,
655 pos: 0,
656 b: PhantomData,
657 });
658 let v = seed.deserialize(&mut de).map(Some);
659 self.de.0.pos += de.0.pos;
660
661 if de.0.sig_parser.next_char() == STRUCT_SIG_END_CHAR {
662 // Last item in the struct
663 de.0.sig_parser.skip_char()?;
664
665 // Skip over the framing offsets (if any)
666 self.de.0.pos += self.offsets_len;
667 }
668
669 self.de.0.sig_parser = de.0.sig_parser;
670
671 v
672 }
673 }
674
675 #[derive(Debug)]
676 struct ValueDeserializer<'d, 'de, 'sig, 'f, B> {
677 de: &'d mut Deserializer<'de, 'sig, 'f, B>,
678 stage: ValueParseStage,
679 sig_start: usize,
680 sig_end: usize,
681 value_start: usize,
682 value_end: usize,
683 }
684
685 impl<'d, 'de, 'sig, 'f, B> ValueDeserializer<'d, 'de, 'sig, 'f, B>
686 where
687 B: byteorder::ByteOrder,
688 {
new(de: &'d mut Deserializer<'de, 'sig, 'f, B>) -> Result<Self>689 fn new(de: &'d mut Deserializer<'de, 'sig, 'f, B>) -> Result<Self> {
690 // GVariant format has signature at the end
691 let mut separator_pos = None;
692
693 // Search for the nul byte separator
694 for i in (de.0.pos..de.0.bytes.len() - 1).rev() {
695 if de.0.bytes[i] == b'\0' {
696 separator_pos = Some(i);
697
698 break;
699 }
700 }
701
702 let (sig_start, sig_end, value_start, value_end) = match separator_pos {
703 None => {
704 return Err(de::Error::invalid_value(
705 de::Unexpected::Bytes(&de.0.bytes[de.0.pos..]),
706 &"nul byte separator between Variant's value & signature",
707 ));
708 }
709 Some(separator_pos) => (separator_pos + 1, de.0.bytes.len(), de.0.pos, separator_pos),
710 };
711
712 Ok(ValueDeserializer::<B> {
713 de,
714 stage: ValueParseStage::Signature,
715 sig_start,
716 sig_end,
717 value_start,
718 value_end,
719 })
720 }
721 }
722
723 impl<'d, 'de, 'sig, 'f, B> SeqAccess<'de> for ValueDeserializer<'d, 'de, 'sig, 'f, B>
724 where
725 B: byteorder::ByteOrder,
726 {
727 type Error = Error;
728
next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>> where T: DeserializeSeed<'de>,729 fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>>
730 where
731 T: DeserializeSeed<'de>,
732 {
733 match self.stage {
734 ValueParseStage::Signature => {
735 self.stage = ValueParseStage::Value;
736
737 let signature = Signature::from_static_str_unchecked(VARIANT_SIGNATURE_STR);
738 let sig_parser = SignatureParser::new(signature);
739
740 let mut de = Deserializer::<B>(crate::DeserializerCommon {
741 // No padding in signatures so just pass the same context
742 ctxt: self.de.0.ctxt,
743 sig_parser,
744 bytes: &self.de.0.bytes[self.sig_start..self.sig_end],
745 fds: self.de.0.fds,
746 pos: 0,
747 b: PhantomData,
748 });
749
750 seed.deserialize(&mut de).map(Some)
751 }
752 ValueParseStage::Value => {
753 self.stage = ValueParseStage::Done;
754
755 let slice = &self.de.0.bytes[self.sig_start..self.sig_end];
756 // FIXME: Can we just use `Signature::from_bytes_unchecked`?
757 let signature = Signature::try_from(slice)?;
758 let sig_parser = SignatureParser::new(signature);
759
760 let ctxt = EncodingContext::new(
761 self.de.0.ctxt.format(),
762 self.de.0.ctxt.position() + self.value_start,
763 );
764 let mut de = Deserializer::<B>(crate::DeserializerCommon {
765 ctxt,
766 sig_parser,
767 bytes: &self.de.0.bytes[self.value_start..self.value_end],
768 fds: self.de.0.fds,
769 pos: 0,
770 b: PhantomData,
771 });
772
773 let v = seed.deserialize(&mut de).map(Some);
774
775 self.de.0.pos = self.sig_end;
776
777 v
778 }
779 ValueParseStage::Done => Ok(None),
780 }
781 }
782 }
783
784 impl<'de, 'd, 'sig, 'f, B> crate::de::GetDeserializeCommon<'de, 'sig, 'f, B>
785 for &'d mut Deserializer<'de, 'sig, 'f, B>
786 where
787 B: byteorder::ByteOrder,
788 {
common_mut<'dr>(self) -> &'dr mut crate::de::DeserializerCommon<'de, 'sig, 'f, B> where Self: 'dr,789 fn common_mut<'dr>(self) -> &'dr mut crate::de::DeserializerCommon<'de, 'sig, 'f, B>
790 where
791 Self: 'dr,
792 {
793 &mut self.0
794 }
795 }
796
797 impl<'de, 'd, 'sig, 'f, B> EnumAccess<'de>
798 for crate::de::Enum<B, &'d mut Deserializer<'de, 'sig, 'f, B>>
799 where
800 B: byteorder::ByteOrder,
801 {
802 type Error = Error;
803 type Variant = Self;
804
variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)> where V: DeserializeSeed<'de>,805 fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant)>
806 where
807 V: DeserializeSeed<'de>,
808 {
809 seed.deserialize(&mut *self.de).map(|v| (v, self))
810 }
811 }
812