1use std::{
17 cmp::Ordering,
18 io::{Read, Write},
19};
20
21use crate::{
22 errors::{ParquetError, Result},
23 write_thrift_field,
24};
25use std::io::Error;
26use std::num::TryFromIntError;
27use std::str::Utf8Error;
28
29#[derive(Debug)]
30pub(crate) enum ThriftProtocolError {
31 Eof,
32 IO(Error),
33 InvalidFieldType(u8),
34 InvalidElementType(u8),
35 FieldDeltaOverflow { field_delta: u8, last_field_id: i16 },
36 InvalidBoolean(u8),
37 IntegerOverflow,
38 Utf8Error,
39 SkipDepth(FieldType),
40 SkipUnsupportedType(FieldType),
41}
42
43impl From<ThriftProtocolError> for ParquetError {
44 #[inline(never)]
45 fn from(e: ThriftProtocolError) -> Self {
46 match e {
47 ThriftProtocolError::Eof => eof_err!("Unexpected EOF"),
48 ThriftProtocolError::IO(e) => e.into(),
49 ThriftProtocolError::InvalidFieldType(value) => match FieldType::try_from(value) {
50 Ok(fld_type) => general_err!("Unexpected struct field type {:?}", fld_type),
51 Err(_) => general_err!("Unexpected struct field type {}", value),
52 },
53 ThriftProtocolError::InvalidElementType(value) => {
54 general_err!("Unexpected list/set element type {}", value)
55 }
56 ThriftProtocolError::FieldDeltaOverflow {
57 field_delta,
58 last_field_id,
59 } => general_err!("cannot add {} to {}", field_delta, last_field_id),
60 ThriftProtocolError::InvalidBoolean(value) => {
61 general_err!("cannot convert {} into bool", value)
62 }
63 ThriftProtocolError::IntegerOverflow => {
64 general_err!("integer overflow decoding thrift value")
65 }
66 ThriftProtocolError::Utf8Error => general_err!("invalid utf8"),
67 ThriftProtocolError::SkipDepth(field_type) => {
68 general_err!("cannot parse past {:?}", field_type)
69 }
70 ThriftProtocolError::SkipUnsupportedType(field_type) => {
71 general_err!("cannot skip field type {:?}", field_type)
72 }
73 }
74 }
75}
76
77impl From<Utf8Error> for ThriftProtocolError {
78 fn from(_: Utf8Error) -> Self {
79 Self::Utf8Error
81 }
82}
83
84impl From<Error> for ThriftProtocolError {
85 fn from(e: Error) -> Self {
86 Self::IO(e)
87 }
88}
89
90impl From<TryFromIntError> for ThriftProtocolError {
91 fn from(_: TryFromIntError) -> Self {
92 Self::IntegerOverflow
94 }
95}
96
97pub type ThriftProtocolResult<T> = Result<T, ThriftProtocolError>;
98
99#[derive(Debug, Clone, Copy, PartialEq)]
103pub struct OrderedF64(f64);
104
105impl From<f64> for OrderedF64 {
106 fn from(value: f64) -> Self {
107 Self(value)
108 }
109}
110
111impl From<OrderedF64> for f64 {
112 fn from(value: OrderedF64) -> Self {
113 value.0
114 }
115}
116
117impl Eq for OrderedF64 {} impl Ord for OrderedF64 {
120 fn cmp(&self, other: &Self) -> Ordering {
121 self.0.total_cmp(&other.0)
122 }
123}
124
125impl PartialOrd for OrderedF64 {
126 fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
127 Some(self.cmp(other))
128 }
129}
130
131#[derive(Clone, Copy, Debug, Eq, PartialEq)]
133pub(crate) enum FieldType {
134 Stop = 0,
135 BooleanTrue = 1,
136 BooleanFalse = 2,
137 Byte = 3,
138 I16 = 4,
139 I32 = 5,
140 I64 = 6,
141 Double = 7,
142 Binary = 8,
143 List = 9,
144 Set = 10,
145 Map = 11,
146 Struct = 12,
147 Uuid = 13,
148}
149
150impl TryFrom<u8> for FieldType {
151 type Error = ThriftProtocolError;
152 fn try_from(value: u8) -> ThriftProtocolResult<Self> {
153 match value {
154 0 => Ok(Self::Stop),
155 1 => Ok(Self::BooleanTrue),
156 2 => Ok(Self::BooleanFalse),
157 3 => Ok(Self::Byte),
158 4 => Ok(Self::I16),
159 5 => Ok(Self::I32),
160 6 => Ok(Self::I64),
161 7 => Ok(Self::Double),
162 8 => Ok(Self::Binary),
163 9 => Ok(Self::List),
164 10 => Ok(Self::Set),
165 11 => Ok(Self::Map),
166 12 => Ok(Self::Struct),
167 13 => Ok(Self::Uuid),
168 _ => Err(ThriftProtocolError::InvalidFieldType(value)),
169 }
170 }
171}
172
173impl From<ElementType> for FieldType {
174 fn from(value: ElementType) -> Self {
175 match value {
176 ElementType::Bool => Self::BooleanTrue,
177 ElementType::Byte => Self::Byte,
178 ElementType::I16 => Self::I16,
179 ElementType::I32 => Self::I32,
180 ElementType::I64 => Self::I64,
181 ElementType::Double => Self::Double,
182 ElementType::Binary => Self::Binary,
183 ElementType::List => Self::List,
184 ElementType::Set => Self::Set,
185 ElementType::Map => Self::Map,
186 ElementType::Struct => Self::Struct,
187 ElementType::Uuid => Self::Uuid,
188 }
189 }
190}
191
192#[derive(Clone, Copy, Debug, Eq, PartialEq)]
194pub(crate) enum ElementType {
195 Bool = 2,
196 Byte = 3,
197 I16 = 4,
198 I32 = 5,
199 I64 = 6,
200 Double = 7,
201 Binary = 8,
202 List = 9,
203 Set = 10,
204 Map = 11,
205 Struct = 12,
206 Uuid = 13,
207}
208
209impl TryFrom<u8> for ElementType {
210 type Error = ThriftProtocolError;
211 fn try_from(value: u8) -> ThriftProtocolResult<Self> {
212 match value {
213 1 | 2 => Ok(Self::Bool),
219 3 => Ok(Self::Byte),
220 4 => Ok(Self::I16),
221 5 => Ok(Self::I32),
222 6 => Ok(Self::I64),
223 7 => Ok(Self::Double),
224 8 => Ok(Self::Binary),
225 9 => Ok(Self::List),
226 10 => Ok(Self::Set),
227 11 => Ok(Self::Map),
228 12 => Ok(Self::Struct),
229 13 => Ok(Self::Uuid),
230 _ => Err(ThriftProtocolError::InvalidElementType(value)),
231 }
232 }
233}
234
235pub(crate) struct FieldIdentifier {
239 pub(crate) field_type: FieldType,
241 pub(crate) id: i16,
243}
244
245impl FieldIdentifier {
246 pub(crate) fn bool_val(&self) -> ThriftProtocolResult<bool> {
247 match self.field_type {
248 FieldType::BooleanTrue => Ok(true),
249 FieldType::BooleanFalse => Ok(false),
250 _ => Err(ThriftProtocolError::InvalidFieldType(self.field_type as u8)),
251 }
252 }
253}
254
255#[derive(Clone, Debug, Eq, PartialEq)]
259pub(crate) struct ListIdentifier {
260 pub(crate) element_type: ElementType,
262 pub(crate) size: i32,
264}
265
266pub(crate) trait ThriftCompactInputProtocol<'a> {
274 fn read_byte(&mut self) -> ThriftProtocolResult<u8>;
276
277 fn read_bytes(&mut self) -> ThriftProtocolResult<&'a [u8]>;
281
282 fn read_bytes_owned(&mut self) -> ThriftProtocolResult<Vec<u8>>;
283
284 fn skip_bytes(&mut self, n: usize) -> ThriftProtocolResult<()>;
286
287 fn remaining_bytes(&self) -> Option<usize> {
292 None
293 }
294
295 fn read_vlq(&mut self) -> ThriftProtocolResult<u64> {
297 let byte = self.read_byte()?;
299 if byte & 0x80 == 0 {
300 return Ok(byte as u64);
301 }
302 let mut in_progress = (byte & 0x7f) as u64;
303 let mut shift = 7;
304 loop {
305 let byte = self.read_byte()?;
306 in_progress |= ((byte & 0x7F) as u64).wrapping_shl(shift);
307 if byte & 0x80 == 0 {
308 return Ok(in_progress);
309 }
310 shift += 7;
311 }
312 }
313
314 fn read_binary_len(&mut self) -> ThriftProtocolResult<usize> {
316 Ok(i32::try_from(self.read_vlq()?)? as usize)
317 }
318
319 fn read_zig_zag(&mut self) -> ThriftProtocolResult<i64> {
321 let val = self.read_vlq()?;
322 Ok((val >> 1) as i64 ^ -((val & 1) as i64))
323 }
324
325 fn read_list_begin(&mut self) -> ThriftProtocolResult<ListIdentifier> {
327 let header = self.read_byte()?;
328 if header == 0 {
331 return Ok(ListIdentifier {
332 element_type: ElementType::Byte,
333 size: 0,
334 });
335 }
336 let element_type = ElementType::try_from(header & 0x0f)?;
337
338 let possible_element_count = (header & 0xF0) >> 4;
339 let element_count = if possible_element_count != 15 {
340 possible_element_count as i32
342 } else {
343 i32::try_from(self.read_vlq()?)?
350 };
351
352 Ok(ListIdentifier {
353 element_type,
354 size: element_count,
355 })
356 }
357
358 #[cold]
362 fn read_full_field_id(&mut self) -> ThriftProtocolResult<i16> {
363 self.read_i16()
364 }
365
366 fn read_field_begin(&mut self, last_field_id: i16) -> ThriftProtocolResult<FieldIdentifier> {
368 let field_type = self.read_byte()?;
372 if field_type & 0xf == 0 {
373 return Ok(FieldIdentifier {
374 field_type: FieldType::Stop,
375 id: 0,
376 });
377 }
378
379 let field_delta = (field_type & 0xf0) >> 4;
380 let field_type = FieldType::try_from(field_type & 0xf)?;
381
382 let id = if field_delta != 0 {
383 last_field_id.checked_add(field_delta as i16).ok_or(
384 ThriftProtocolError::FieldDeltaOverflow {
385 field_delta,
386 last_field_id,
387 },
388 )?
389 } else {
390 self.read_full_field_id()?
391 };
392
393 Ok(FieldIdentifier { field_type, id })
394 }
395
396 fn read_field_header(&mut self) -> ThriftProtocolResult<(u8, u8)> {
403 let field_type = self.read_byte()?;
404 let field_delta = (field_type & 0xf0) >> 4;
405 let field_type = field_type & 0xf;
406 Ok((field_type, field_delta))
407 }
408
409 fn read_bool(&mut self) -> ThriftProtocolResult<bool> {
412 let b = self.read_byte()?;
413 match b {
418 0x01 => Ok(true),
419 0x00 | 0x02 => Ok(false),
420 _ => Err(ThriftProtocolError::InvalidBoolean(b)),
421 }
422 }
423
424 fn read_string(&mut self) -> ThriftProtocolResult<&'a str> {
428 let slice = self.read_bytes()?;
429 Ok(std::str::from_utf8(slice)?)
430 }
431
432 fn read_i8(&mut self) -> ThriftProtocolResult<i8> {
434 Ok(self.read_byte()? as _)
435 }
436
437 fn read_i16(&mut self) -> ThriftProtocolResult<i16> {
439 Ok(self.read_zig_zag()? as _)
440 }
441
442 fn read_i32(&mut self) -> ThriftProtocolResult<i32> {
444 Ok(self.read_zig_zag()? as _)
445 }
446
447 fn read_i64(&mut self) -> ThriftProtocolResult<i64> {
449 self.read_zig_zag()
450 }
451
452 fn read_double(&mut self) -> ThriftProtocolResult<f64>;
454
455 fn skip_vlq(&mut self) -> ThriftProtocolResult<()> {
457 loop {
458 let byte = self.read_byte()?;
459 if byte & 0x80 == 0 {
460 return Ok(());
461 }
462 }
463 }
464
465 fn skip_binary(&mut self) -> ThriftProtocolResult<()> {
469 let len = self.read_binary_len()?;
470 self.skip_bytes(len)
471 }
472
473 fn skip(&mut self, field_type: FieldType) -> ThriftProtocolResult<()> {
476 const DEFAULT_SKIP_DEPTH: i8 = 64;
477 self.skip_till_depth(field_type, DEFAULT_SKIP_DEPTH)
478 }
479
480 fn skip_empty_struct(&mut self) -> Result<()> {
484 let b = self.read_byte()?;
485 if b != 0 {
486 Err(general_err!("Empty struct has fields"))
487 } else {
488 Ok(())
489 }
490 }
491
492 fn skip_till_depth(&mut self, field_type: FieldType, depth: i8) -> ThriftProtocolResult<()> {
494 if depth == 0 {
495 return Err(ThriftProtocolError::SkipDepth(field_type));
496 }
497
498 match field_type {
499 FieldType::BooleanFalse | FieldType::BooleanTrue => Ok(()),
501 FieldType::Byte => self.read_i8().map(|_| ()),
502 FieldType::I16 => self.skip_vlq(),
503 FieldType::I32 => self.skip_vlq(),
504 FieldType::I64 => self.skip_vlq(),
505 FieldType::Double => self.skip_bytes(8),
506 FieldType::Binary => self.skip_binary(),
507 FieldType::Struct => {
509 loop {
510 let field_ident = self.read_field_begin(0)?;
512 if field_ident.field_type == FieldType::Stop {
513 break;
514 }
515 self.skip_till_depth(field_ident.field_type, depth - 1)?;
516 }
517 Ok(())
518 }
519 FieldType::List | FieldType::Set => {
522 let list_ident = self.read_list_begin()?;
523 if list_ident.element_type == ElementType::Bool {
524 self.skip_bool_list(list_ident.size, depth - 1)
525 } else {
526 let field_type = list_ident.element_type.into();
527 for _ in 0..list_ident.size {
528 self.skip_till_depth(field_type, depth - 1)?;
529 }
530 Ok(())
531 }
532 }
533 FieldType::Map => self.skip_map(depth),
535 FieldType::Uuid => self.skip_bytes(16),
537 FieldType::Stop => Err(ThriftProtocolError::SkipUnsupportedType(field_type)),
538 }
539 }
540
541 #[cold]
543 fn skip_bool_list(&mut self, size: i32, depth: i8) -> ThriftProtocolResult<()> {
544 if size > 0 && depth == 0 {
545 return Err(ThriftProtocolError::SkipDepth(FieldType::BooleanTrue));
546 }
547 self.skip_bytes(size as usize)
548 }
549
550 #[cold]
552 fn skip_map(&mut self, depth: i8) -> ThriftProtocolResult<()> {
553 let size = i32::try_from(self.read_vlq()?)?;
554 if size > 0 {
555 let kv = self.read_byte()?;
556 let key_type = ElementType::try_from(kv >> 4)?;
557 let val_type = ElementType::try_from(kv & 0xf)?;
558 for _ in 0..size {
559 self.skip_element_till_depth(key_type, depth - 1)?;
560 self.skip_element_till_depth(val_type, depth - 1)?;
561 }
562 }
563 Ok(())
564 }
565
566 fn skip_element_till_depth(
568 &mut self,
569 element_type: ElementType,
570 depth: i8,
571 ) -> ThriftProtocolResult<()> {
572 if depth == 0 {
573 return Err(ThriftProtocolError::SkipDepth(element_type.into()));
574 }
575 match element_type {
576 ElementType::Bool => self.skip_bytes(1),
577 other => self.skip_till_depth(other.into(), depth),
578 }
579 }
580}
581
582pub(crate) struct ThriftSliceInputProtocol<'a> {
584 buf: &'a [u8],
585}
586
587impl<'a> ThriftSliceInputProtocol<'a> {
588 pub fn new(buf: &'a [u8]) -> Self {
590 Self { buf }
591 }
592
593 pub fn as_slice(&self) -> &'a [u8] {
595 self.buf
596 }
597}
598
599impl<'b, 'a: 'b> ThriftCompactInputProtocol<'b> for ThriftSliceInputProtocol<'a> {
600 #[inline]
601 fn read_byte(&mut self) -> ThriftProtocolResult<u8> {
602 let ret = *self.buf.first().ok_or(ThriftProtocolError::Eof)?;
603 self.buf = &self.buf[1..];
604 Ok(ret)
605 }
606
607 fn read_bytes(&mut self) -> ThriftProtocolResult<&'b [u8]> {
608 let len = self.read_binary_len()?;
609 let ret = self.buf.get(..len).ok_or(ThriftProtocolError::Eof)?;
610 self.buf = &self.buf[len..];
611 Ok(ret)
612 }
613
614 fn read_bytes_owned(&mut self) -> ThriftProtocolResult<Vec<u8>> {
615 Ok(self.read_bytes()?.to_vec())
616 }
617
618 #[inline]
619 fn skip_bytes(&mut self, n: usize) -> ThriftProtocolResult<()> {
620 self.buf.get(..n).ok_or(ThriftProtocolError::Eof)?;
621 self.buf = &self.buf[n..];
622 Ok(())
623 }
624
625 fn read_double(&mut self) -> ThriftProtocolResult<f64> {
626 let slice = self.buf.get(..8).ok_or(ThriftProtocolError::Eof)?;
627 self.buf = &self.buf[8..];
628 match slice.try_into() {
629 Ok(slice) => Ok(f64::from_le_bytes(slice)),
630 Err(_) => unreachable!(),
631 }
632 }
633
634 fn remaining_bytes(&self) -> Option<usize> {
635 Some(self.buf.len())
636 }
637}
638
639pub(crate) struct ThriftReadInputProtocol<R: Read> {
644 reader: R,
645}
646
647impl<R: Read> ThriftReadInputProtocol<R> {
648 pub(crate) fn new(reader: R) -> Self {
649 Self { reader }
650 }
651}
652
653impl<'a, R: Read> ThriftCompactInputProtocol<'a> for ThriftReadInputProtocol<R> {
654 #[inline]
655 fn read_byte(&mut self) -> ThriftProtocolResult<u8> {
656 let mut buf = [0_u8; 1];
657 self.reader.read_exact(&mut buf)?;
658 Ok(buf[0])
659 }
660
661 fn read_bytes(&mut self) -> ThriftProtocolResult<&'a [u8]> {
662 unimplemented!()
663 }
664
665 fn read_bytes_owned(&mut self) -> ThriftProtocolResult<Vec<u8>> {
666 let len = self.read_binary_len()?;
667 let mut v = Vec::with_capacity(len.min(8 * 1024));
668 let copied = std::io::copy(&mut self.reader.by_ref().take(len as u64), &mut v)?;
669 if copied != len as u64 {
670 return Err(ThriftProtocolError::Eof);
671 }
672 Ok(v)
673 }
674
675 fn skip_bytes(&mut self, n: usize) -> ThriftProtocolResult<()> {
676 let skipped = std::io::copy(
677 &mut self.reader.by_ref().take(n as u64),
678 &mut std::io::sink(),
679 )?;
680 if skipped != n as u64 {
681 return Err(ThriftProtocolError::Eof);
682 }
683 Ok(())
684 }
685
686 fn read_double(&mut self) -> ThriftProtocolResult<f64> {
687 let mut buf = [0_u8; 8];
688 self.reader.read_exact(&mut buf)?;
689 Ok(f64::from_le_bytes(buf))
690 }
691}
692
693pub(crate) trait ReadThrift<'a, R: ThriftCompactInputProtocol<'a>> {
696 fn read_thrift(prot: &mut R) -> Result<Self>
698 where
699 Self: Sized;
700}
701
702impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for bool {
703 fn read_thrift(prot: &mut R) -> Result<Self> {
704 Ok(prot.read_bool()?)
705 }
706}
707
708impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for i8 {
709 fn read_thrift(prot: &mut R) -> Result<Self> {
710 Ok(prot.read_i8()?)
711 }
712}
713
714impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for i16 {
715 fn read_thrift(prot: &mut R) -> Result<Self> {
716 Ok(prot.read_i16()?)
717 }
718}
719
720impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for i32 {
721 fn read_thrift(prot: &mut R) -> Result<Self> {
722 Ok(prot.read_i32()?)
723 }
724}
725
726impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for i64 {
727 fn read_thrift(prot: &mut R) -> Result<Self> {
728 Ok(prot.read_i64()?)
729 }
730}
731
732impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for OrderedF64 {
733 fn read_thrift(prot: &mut R) -> Result<Self> {
734 Ok(OrderedF64(prot.read_double()?))
735 }
736}
737
738impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for &'a str {
739 fn read_thrift(prot: &mut R) -> Result<Self> {
740 Ok(prot.read_string()?)
741 }
742}
743
744impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for String {
745 fn read_thrift(prot: &mut R) -> Result<Self> {
746 Ok(String::from_utf8(prot.read_bytes_owned()?)?)
747 }
748}
749
750impl<'a, R: ThriftCompactInputProtocol<'a>> ReadThrift<'a, R> for &'a [u8] {
751 fn read_thrift(prot: &mut R) -> Result<Self> {
752 Ok(prot.read_bytes()?)
753 }
754}
755
756pub(crate) fn read_thrift_vec<'a, T, R>(prot: &mut R) -> Result<Vec<T>>
760where
761 R: ThriftCompactInputProtocol<'a>,
762 T: ReadThrift<'a, R> + WriteThrift,
763{
764 let list_ident = prot.read_list_begin()?;
765 validate_list_type(T::ELEMENT_TYPE, &list_ident)?;
766 let size = list_ident.size as usize;
767 check_list_size(prot.remaining_bytes(), size)?;
768 let mut res = Vec::with_capacity(size);
769 for _ in 0..list_ident.size {
770 let val = T::read_thrift(prot)?;
771 res.push(val);
772 }
773 Ok(res)
774}
775
776pub(crate) fn validate_list_type(expected: ElementType, got: &ListIdentifier) -> Result<()> {
777 if got.element_type != expected && got.size != 0 {
780 return Err(general_err!(
781 "Expected list element type of {:?} but got {:?}",
782 expected,
783 got.element_type
784 ));
785 }
786 Ok(())
787}
788
789pub(crate) fn check_list_size(remaining: Option<usize>, size: usize) -> Result<()> {
795 if let Some(remaining) = remaining
796 && size > remaining
797 {
798 return Err(general_err!(
799 "Thrift list size {size} exceeds remaining input length {remaining}"
800 ));
801 }
802 Ok(())
803}
804
805pub(crate) struct ThriftCompactOutputProtocol<W: Write> {
817 writer: W,
818 write_path_in_schema: bool,
819 write_rg_ordinal: bool,
820}
821
822impl<W: Write> ThriftCompactOutputProtocol<W> {
823 pub(crate) fn new(writer: W) -> Self {
825 Self {
826 writer,
827 write_path_in_schema: true,
828 write_rg_ordinal: true,
829 }
830 }
831
832 pub(crate) fn set_write_path_in_schema(&mut self, val: bool) {
837 self.write_path_in_schema = val;
838 }
839
840 pub(crate) fn write_path_in_schema(&self) -> bool {
842 self.write_path_in_schema
843 }
844
845 pub(crate) fn set_write_row_group_ordinal(&mut self, val: bool) {
852 self.write_rg_ordinal = val;
853 }
854
855 pub(crate) fn write_row_group_ordinal(&self) -> bool {
857 self.write_rg_ordinal
858 }
859
860 fn write_byte(&mut self, b: u8) -> Result<()> {
862 self.writer.write_all(&[b])?;
863 Ok(())
864 }
865
866 fn write_vlq(&mut self, val: u64) -> Result<()> {
868 let mut v = val;
869 while v > 0x7f {
870 self.write_byte(v as u8 | 0x80)?;
871 v >>= 7;
872 }
873 self.write_byte(v as u8)
874 }
875
876 fn write_zig_zag(&mut self, val: i64) -> Result<()> {
878 let s = (val < 0) as i64;
879 self.write_vlq((((val ^ -s) << 1) + s) as u64)
880 }
881
882 pub(crate) fn write_field_begin(
887 &mut self,
888 field_type: FieldType,
889 field_id: i16,
890 last_field_id: i16,
891 ) -> Result<()> {
892 let delta = field_id.wrapping_sub(last_field_id);
893 if delta > 0 && delta <= 0xf {
894 self.write_byte(((delta as u8) << 4) | field_type as u8)
895 } else {
896 self.write_byte(field_type as u8)?;
897 self.write_i16(field_id)
898 }
899 }
900
901 pub(crate) fn write_list_begin(&mut self, element_type: ElementType, len: usize) -> Result<()> {
903 if len < 15 {
904 self.write_byte(((len as u8) << 4) | element_type as u8)
905 } else {
906 self.write_byte(0xf0u8 | element_type as u8)?;
907 self.write_vlq(len as _)
908 }
909 }
910
911 pub(crate) fn write_struct_end(&mut self) -> Result<()> {
914 self.write_byte(0)
915 }
916
917 pub(crate) fn write_bytes(&mut self, val: &[u8]) -> Result<()> {
920 self.write_vlq(val.len() as u64)?;
921 self.writer.write_all(val)?;
922 Ok(())
923 }
924
925 pub(crate) fn write_empty_struct(&mut self, field_id: i16, last_field_id: i16) -> Result<i16> {
928 self.write_field_begin(FieldType::Struct, field_id, last_field_id)?;
929 self.write_struct_end()?;
930 Ok(last_field_id)
931 }
932
933 pub(crate) fn write_bool(&mut self, val: bool) -> Result<()> {
935 match val {
936 true => self.write_byte(1),
937 false => self.write_byte(2),
938 }
939 }
940
941 pub(crate) fn write_i8(&mut self, val: i8) -> Result<()> {
943 self.write_byte(val as u8)
944 }
945
946 pub(crate) fn write_i16(&mut self, val: i16) -> Result<()> {
948 self.write_zig_zag(val as _)
949 }
950
951 pub(crate) fn write_i32(&mut self, val: i32) -> Result<()> {
953 self.write_zig_zag(val as _)
954 }
955
956 pub(crate) fn write_i64(&mut self, val: i64) -> Result<()> {
958 self.write_zig_zag(val)
959 }
960
961 pub(crate) fn write_double(&mut self, val: f64) -> Result<()> {
963 self.writer.write_all(&val.to_le_bytes())?;
964 Ok(())
965 }
966}
967
968pub(crate) trait WriteThrift {
973 const ELEMENT_TYPE: ElementType;
975
976 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()>;
978}
979
980impl<T> WriteThrift for Vec<T>
983where
984 T: WriteThrift,
985{
986 const ELEMENT_TYPE: ElementType = ElementType::List;
987
988 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
989 writer.write_list_begin(T::ELEMENT_TYPE, self.len())?;
990 for item in self {
991 item.write_thrift(writer)?;
992 }
993 Ok(())
994 }
995}
996
997impl WriteThrift for bool {
998 const ELEMENT_TYPE: ElementType = ElementType::Bool;
999
1000 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1001 writer.write_bool(*self)
1002 }
1003}
1004
1005impl WriteThrift for i8 {
1006 const ELEMENT_TYPE: ElementType = ElementType::Byte;
1007
1008 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1009 writer.write_i8(*self)
1010 }
1011}
1012
1013impl WriteThrift for i16 {
1014 const ELEMENT_TYPE: ElementType = ElementType::I16;
1015
1016 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1017 writer.write_i16(*self)
1018 }
1019}
1020
1021impl WriteThrift for i32 {
1022 const ELEMENT_TYPE: ElementType = ElementType::I32;
1023
1024 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1025 writer.write_i32(*self)
1026 }
1027}
1028
1029impl WriteThrift for i64 {
1030 const ELEMENT_TYPE: ElementType = ElementType::I64;
1031
1032 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1033 writer.write_i64(*self)
1034 }
1035}
1036
1037impl WriteThrift for OrderedF64 {
1038 const ELEMENT_TYPE: ElementType = ElementType::Double;
1039
1040 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1041 writer.write_double(self.0)
1042 }
1043}
1044
1045impl WriteThrift for f64 {
1046 const ELEMENT_TYPE: ElementType = ElementType::Double;
1047
1048 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1049 writer.write_double(*self)
1050 }
1051}
1052
1053impl WriteThrift for &[u8] {
1054 const ELEMENT_TYPE: ElementType = ElementType::Binary;
1055
1056 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1057 writer.write_bytes(self)
1058 }
1059}
1060
1061impl WriteThrift for &str {
1062 const ELEMENT_TYPE: ElementType = ElementType::Binary;
1063
1064 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1065 writer.write_bytes(self.as_bytes())
1066 }
1067}
1068
1069impl WriteThrift for String {
1070 const ELEMENT_TYPE: ElementType = ElementType::Binary;
1071
1072 fn write_thrift<W: Write>(&self, writer: &mut ThriftCompactOutputProtocol<W>) -> Result<()> {
1073 writer.write_bytes(self.as_bytes())
1074 }
1075}
1076
1077pub(crate) trait WriteThriftField {
1120 fn write_thrift_field<W: Write>(
1127 &self,
1128 writer: &mut ThriftCompactOutputProtocol<W>,
1129 field_id: i16,
1130 last_field_id: i16,
1131 ) -> Result<i16>;
1132}
1133
1134impl WriteThriftField for bool {
1136 fn write_thrift_field<W: Write>(
1137 &self,
1138 writer: &mut ThriftCompactOutputProtocol<W>,
1139 field_id: i16,
1140 last_field_id: i16,
1141 ) -> Result<i16> {
1142 match *self {
1144 true => writer.write_field_begin(FieldType::BooleanTrue, field_id, last_field_id)?,
1145 false => writer.write_field_begin(FieldType::BooleanFalse, field_id, last_field_id)?,
1146 }
1147 Ok(field_id)
1148 }
1149}
1150
1151write_thrift_field!(i8, FieldType::Byte);
1152write_thrift_field!(i16, FieldType::I16);
1153write_thrift_field!(i32, FieldType::I32);
1154write_thrift_field!(i64, FieldType::I64);
1155write_thrift_field!(OrderedF64, FieldType::Double);
1156write_thrift_field!(f64, FieldType::Double);
1157write_thrift_field!(String, FieldType::Binary);
1158
1159impl WriteThriftField for &[u8] {
1160 fn write_thrift_field<W: Write>(
1161 &self,
1162 writer: &mut ThriftCompactOutputProtocol<W>,
1163 field_id: i16,
1164 last_field_id: i16,
1165 ) -> Result<i16> {
1166 writer.write_field_begin(FieldType::Binary, field_id, last_field_id)?;
1167 writer.write_bytes(self)?;
1168 Ok(field_id)
1169 }
1170}
1171
1172impl WriteThriftField for &str {
1173 fn write_thrift_field<W: Write>(
1174 &self,
1175 writer: &mut ThriftCompactOutputProtocol<W>,
1176 field_id: i16,
1177 last_field_id: i16,
1178 ) -> Result<i16> {
1179 writer.write_field_begin(FieldType::Binary, field_id, last_field_id)?;
1180 writer.write_bytes(self.as_bytes())?;
1181 Ok(field_id)
1182 }
1183}
1184
1185impl<T> WriteThriftField for Vec<T>
1186where
1187 T: WriteThrift,
1188{
1189 fn write_thrift_field<W: Write>(
1190 &self,
1191 writer: &mut ThriftCompactOutputProtocol<W>,
1192 field_id: i16,
1193 last_field_id: i16,
1194 ) -> Result<i16> {
1195 writer.write_field_begin(FieldType::List, field_id, last_field_id)?;
1196 self.write_thrift(writer)?;
1197 Ok(field_id)
1198 }
1199}
1200
1201#[cfg(test)]
1202pub(crate) mod tests {
1203 use crate::basic::{TimeUnit, Type};
1204
1205 use super::*;
1206 use std::fmt::Debug;
1207 use std::io::{ErrorKind, Result as IoResult};
1208
1209 pub(crate) fn test_roundtrip<T>(val: T)
1210 where
1211 T: for<'a> ReadThrift<'a, ThriftSliceInputProtocol<'a>> + WriteThrift + PartialEq + Debug,
1212 {
1213 let mut buf = Vec::<u8>::new();
1214 {
1215 let mut writer = ThriftCompactOutputProtocol::new(&mut buf);
1216 val.write_thrift(&mut writer).unwrap();
1217 }
1218
1219 let mut prot = ThriftSliceInputProtocol::new(&buf);
1220 let read_val = T::read_thrift(&mut prot).unwrap();
1221 assert_eq!(val, read_val);
1222 }
1223
1224 #[test]
1225 fn test_binary_length_bound() {
1226 let oversized = [0x80, 0x80, 0x80, 0x80, 8]; let maximum = [0xff, 0xff, 0xff, 0xff, 7]; for bytes in [&oversized, &maximum] {
1229 let check = |result: ThriftProtocolResult<()>| {
1230 if bytes == &oversized {
1231 assert!(matches!(result, Err(ThriftProtocolError::IntegerOverflow)));
1232 } else {
1233 assert!(matches!(result, Err(ThriftProtocolError::Eof)));
1234 }
1235 };
1236 check(
1237 ThriftSliceInputProtocol::new(bytes)
1238 .read_bytes()
1239 .map(|_| ()),
1240 );
1241 check(
1242 ThriftSliceInputProtocol::new(bytes)
1243 .read_bytes_owned()
1244 .map(|_| ()),
1245 );
1246 check(ThriftSliceInputProtocol::new(bytes).skip_binary());
1247 check(
1248 ThriftReadInputProtocol::new(bytes.as_slice())
1249 .read_bytes_owned()
1250 .map(|_| ()),
1251 );
1252 check(ThriftReadInputProtocol::new(bytes.as_slice()).skip_binary());
1253 }
1254 }
1255
1256 struct FragmentedReader<'a>(&'a [u8]);
1257
1258 impl Read for FragmentedReader<'_> {
1259 fn read(&mut self, buf: &mut [u8]) -> IoResult<usize> {
1260 let len = buf.len().min(2);
1261 self.0.read(&mut buf[..len])
1262 }
1263 }
1264
1265 #[test]
1266 fn test_read_bytes_owned_complete_and_fragmented() {
1267 let large_payload = vec![7; 16 * 1024];
1268 for payload in [b"".as_slice(), b"abcde".as_slice(), &large_payload] {
1269 let mut data = Vec::new();
1270 ThriftCompactOutputProtocol::new(&mut data)
1271 .write_bytes(payload)
1272 .unwrap();
1273 data.push(42);
1274 let mut slice = ThriftSliceInputProtocol::new(&data);
1275 let mut stream = ThriftReadInputProtocol::new(data.as_slice());
1276 let mut fragmented = ThriftReadInputProtocol::new(FragmentedReader(&data));
1277 assert_eq!(slice.read_bytes_owned().unwrap(), payload);
1278 assert_eq!(stream.read_bytes_owned().unwrap(), payload);
1279 assert_eq!(fragmented.read_bytes_owned().unwrap(), payload);
1280 assert_eq!(slice.read_byte().unwrap(), 42);
1281 assert_eq!(stream.read_byte().unwrap(), 42);
1282 assert_eq!(fragmented.read_byte().unwrap(), 42);
1283 }
1284 }
1285
1286 #[test]
1287 fn test_read_bytes_owned_truncated_payload() {
1288 for len in [5, 1024 * 1024, i32::MAX as u64] {
1289 let mut data = Vec::new();
1290 ThriftCompactOutputProtocol::new(&mut data)
1291 .write_vlq(len)
1292 .unwrap();
1293 data.extend_from_slice(b"abc");
1294 let mut stream = ThriftReadInputProtocol::new(FragmentedReader(&data));
1295 assert!(matches!(
1296 stream.read_bytes_owned(),
1297 Err(ThriftProtocolError::Eof)
1298 ));
1299 }
1300 }
1301
1302 #[test]
1303 fn test_read_bytes_owned_preserves_io_error() {
1304 struct FailingReader;
1305 impl Read for FailingReader {
1306 fn read(&mut self, _: &mut [u8]) -> IoResult<usize> {
1307 Err(Error::new(ErrorKind::PermissionDenied, "payload error"))
1308 }
1309 }
1310 let reader = b"\x05ab".as_slice().chain(FailingReader);
1311 let mut stream = ThriftReadInputProtocol::new(reader);
1312 assert!(
1313 matches!(stream.read_bytes_owned(), Err(ThriftProtocolError::IO(e)) if e.kind() == ErrorKind::PermissionDenied)
1314 );
1315 }
1316
1317 #[test]
1318 fn test_enum_roundtrip() {
1319 test_roundtrip(Type::BOOLEAN);
1320 test_roundtrip(Type::INT32);
1321 test_roundtrip(Type::INT64);
1322 test_roundtrip(Type::INT96);
1323 test_roundtrip(Type::FLOAT);
1324 test_roundtrip(Type::DOUBLE);
1325 test_roundtrip(Type::BYTE_ARRAY);
1326 test_roundtrip(Type::FIXED_LEN_BYTE_ARRAY);
1327 }
1328
1329 #[test]
1330 fn test_union_all_empty_roundtrip() {
1331 test_roundtrip(TimeUnit::MILLIS);
1332 test_roundtrip(TimeUnit::MICROS);
1333 test_roundtrip(TimeUnit::NANOS);
1334 }
1335
1336 #[test]
1337 fn test_decode_empty_list() {
1338 let data = vec![0u8; 1];
1339 let mut prot = ThriftSliceInputProtocol::new(&data);
1340 let header = prot.read_list_begin().expect("error reading list header");
1341 assert_eq!(header.size, 0);
1342 assert_eq!(header.element_type, ElementType::Byte);
1343 }
1344
1345 #[test]
1346 fn test_read_empty_list_with_zero_header() {
1347 let data = [0u8];
1348 let mut prot = ThriftSliceInputProtocol::new(&data);
1349 let result = read_thrift_vec::<i32, ThriftSliceInputProtocol>(&mut prot).unwrap();
1350 assert!(result.is_empty());
1351 }
1352
1353 #[test]
1357 fn test_read_list_begin_size_above_i32_max_returns_err() {
1358 let mut data: Vec<u8> = vec![0xF8];
1361 data.extend_from_slice(&[0x80, 0x80, 0x80, 0x80, 0x08]);
1362 let mut prot = ThriftSliceInputProtocol::new(&data);
1363 let result = prot.read_list_begin();
1364 assert!(result.is_err(), "expected error, got {result:?}");
1365 }
1366
1367 crate::thrift_struct! {
1369 struct KnownField {
1370 2: required i32 value;
1371 }
1372 }
1373
1374 #[test]
1375 fn test_skip_boolean_collections_before_known_field() {
1376 for collection_type in [FieldType::List, FieldType::Set] {
1377 let data = [0x10 | collection_type as u8, 0x22, 2, 1, 0x15, 84, 0];
1380 let mut protocol = ThriftSliceInputProtocol::new(&data);
1381 assert_eq!(KnownField::read_thrift(&mut protocol).unwrap().value, 42);
1382 assert!(protocol.as_slice().is_empty());
1383 }
1384 }
1385
1386 #[test]
1387 fn test_skip_map_before_known_field() {
1388 let data = [0x1b, 2, 0x25, 1, 14, 2, 16, 0x15, 84, 0];
1390 let mut protocol = ThriftSliceInputProtocol::new(&data);
1391 assert_eq!(KnownField::read_thrift(&mut protocol).unwrap().value, 42);
1392 assert!(protocol.as_slice().is_empty());
1393 }
1394
1395 #[test]
1396 fn test_read_list_wrong_type() {
1397 let data = [0x42, 0x01];
1399 let mut prot = ThriftSliceInputProtocol::new(&data);
1400 let result = read_thrift_vec::<i32, ThriftSliceInputProtocol>(&mut prot);
1402 println!("{result:?}");
1403 assert!(
1404 result
1405 .unwrap_err()
1406 .to_string()
1407 .contains("Expected list element type of I32 but got Bool")
1408 );
1409 }
1410
1411 #[test]
1412 fn test_read_thrift_vec_roundtrip_i32() {
1413 let data = [0x25, 0x00, 0x00];
1415 let mut prot = ThriftSliceInputProtocol::new(&data);
1416 let result = read_thrift_vec::<i32, ThriftSliceInputProtocol>(&mut prot).unwrap();
1417 assert_eq!(result, vec![0, 0]);
1418 }
1419
1420 #[test]
1421 fn test_read_thrift_vec_size_exceeds_remaining_returns_err() {
1422 let data = [0xE5];
1426 let mut prot = ThriftSliceInputProtocol::new(&data);
1427 let result = read_thrift_vec::<i32, ThriftSliceInputProtocol>(&mut prot);
1428 assert!(result.is_err(), "expected error, got {result:?}");
1429 assert!(
1430 result
1431 .unwrap_err()
1432 .to_string()
1433 .contains("Thrift list size 14 exceeds remaining input length 0")
1434 );
1435 }
1436
1437 #[test]
1438 fn test_read_thrift_vec_huge_declared_size_returns_err() {
1439 let data = [0xF5, 0xfc, 0xfc, 0xfc, 0x33, 0x00, 0x00];
1443 let mut prot = ThriftSliceInputProtocol::new(&data);
1444 let result = read_thrift_vec::<i32, ThriftSliceInputProtocol>(&mut prot);
1445 assert!(result.is_err(), "expected error, got {result:?}");
1446 let err = result.unwrap_err().to_string();
1447 assert!(
1448 err.contains("Thrift list size 109002364 exceeds remaining input length 2"),
1449 "{err}"
1450 );
1451 }
1452}