1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
use super::Error;
use byteorder::{LittleEndian, ReadBytesExt};
use std::io::Cursor;
pub trait Read: ReadBytesExt {
fn read_ptp_u8(&mut self) -> Result<u8, Error> {
Ok(self.read_u8()?)
}
fn read_ptp_i8(&mut self) -> Result<i8, Error> {
Ok(self.read_i8()?)
}
fn read_ptp_u16(&mut self) -> Result<u16, Error> {
Ok(self.read_u16::<LittleEndian>()?)
}
fn read_ptp_i16(&mut self) -> Result<i16, Error> {
Ok(self.read_i16::<LittleEndian>()?)
}
fn read_ptp_u32(&mut self) -> Result<u32, Error> {
Ok(self.read_u32::<LittleEndian>()?)
}
fn read_ptp_i32(&mut self) -> Result<i32, Error> {
Ok(self.read_i32::<LittleEndian>()?)
}
fn read_ptp_u64(&mut self) -> Result<u64, Error> {
Ok(self.read_u64::<LittleEndian>()?)
}
fn read_ptp_i64(&mut self) -> Result<i64, Error> {
Ok(self.read_i64::<LittleEndian>()?)
}
fn read_ptp_u128(&mut self) -> Result<u128, Error> {
Ok(self.read_u128::<LittleEndian>()?)
}
fn read_ptp_i128(&mut self) -> Result<i128, Error> {
Ok(self.read_i128::<LittleEndian>()?)
}
#[inline(always)]
fn read_ptp_vec<T: Sized, U: Fn(&mut Self) -> Result<T, Error>>(
&mut self,
func: U,
) -> Result<Vec<T>, Error> {
let len = self.read_u32::<LittleEndian>()? as usize;
(0..len).map(|_| func(self)).collect()
}
fn read_ptp_u8_vec(&mut self) -> Result<Vec<u8>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_u8())
}
fn read_ptp_i8_vec(&mut self) -> Result<Vec<i8>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_i8())
}
fn read_ptp_u16_vec(&mut self) -> Result<Vec<u16>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_u16())
}
fn read_ptp_i16_vec(&mut self) -> Result<Vec<i16>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_i16())
}
fn read_ptp_u32_vec(&mut self) -> Result<Vec<u32>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_u32())
}
fn read_ptp_i32_vec(&mut self) -> Result<Vec<i32>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_i32())
}
fn read_ptp_u64_vec(&mut self) -> Result<Vec<u64>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_u64())
}
fn read_ptp_i64_vec(&mut self) -> Result<Vec<i64>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_i64())
}
fn read_ptp_u128_vec(&mut self) -> Result<Vec<u128>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_u128())
}
fn read_ptp_i128_vec(&mut self) -> Result<Vec<i128>, Error> {
self.read_ptp_vec(|cur| cur.read_ptp_i128())
}
fn read_ptp_str(&mut self) -> Result<String, Error> {
let len = self.read_u8()?;
if len > 0 {
let data: Vec<u16> = (0..(len - 1))
.map(|_| self.read_u16::<LittleEndian>())
.collect::<std::result::Result<_, _>>()?;
self.read_u16::<LittleEndian>()?;
String::from_utf16(&data)
.map_err(|_| Error::Malformed(format!("Invalid UTF16 data: {:?}", data)))
} else {
Ok("".into())
}
}
fn expect_end(&mut self) -> Result<(), Error>;
}
impl<T: AsRef<[u8]>> Read for Cursor<T> {
fn expect_end(&mut self) -> Result<(), Error> {
let len = self.get_ref().as_ref().len();
if len as u64 != self.position() {
Err(Error::Malformed(format!(
"Response {} bytes, expected {} bytes",
len,
self.position()
)))
} else {
Ok(())
}
}
}