1 use std::convert::TryInto;
2 use std::fmt::Debug;
3
4 /// Read from a byte slice.
5 pub struct Reader<'a> {
6 buf: &'a [u8],
7 offs: usize,
8 }
9
10 impl<'a> Reader<'a> {
init(bytes: &[u8]) -> Reader11 pub fn init(bytes: &[u8]) -> Reader {
12 Reader {
13 buf: bytes,
14 offs: 0,
15 }
16 }
17
rest(&mut self) -> &[u8]18 pub fn rest(&mut self) -> &[u8] {
19 let ret = &self.buf[self.offs..];
20 self.offs = self.buf.len();
21 ret
22 }
23
take(&mut self, len: usize) -> Option<&[u8]>24 pub fn take(&mut self, len: usize) -> Option<&[u8]> {
25 if self.left() < len {
26 return None;
27 }
28
29 let current = self.offs;
30 self.offs += len;
31 Some(&self.buf[current..current + len])
32 }
33
any_left(&self) -> bool34 pub fn any_left(&self) -> bool {
35 self.offs < self.buf.len()
36 }
37
left(&self) -> usize38 pub fn left(&self) -> usize {
39 self.buf.len() - self.offs
40 }
41
used(&self) -> usize42 pub fn used(&self) -> usize {
43 self.offs
44 }
45
sub(&mut self, len: usize) -> Option<Reader>46 pub fn sub(&mut self, len: usize) -> Option<Reader> {
47 self.take(len).map(Reader::init)
48 }
49 }
50
51 /// Things we can encode and read from a Reader.
52 pub trait Codec: Debug + Sized {
53 /// Encode yourself by appending onto `bytes`.
encode(&self, bytes: &mut Vec<u8>)54 fn encode(&self, bytes: &mut Vec<u8>);
55
56 /// Decode yourself by fiddling with the `Reader`.
57 /// Return Some if it worked, None if not.
read(_: &mut Reader) -> Option<Self>58 fn read(_: &mut Reader) -> Option<Self>;
59
60 /// Convenience function to get the results of `encode()`.
get_encoding(&self) -> Vec<u8>61 fn get_encoding(&self) -> Vec<u8> {
62 let mut ret = Vec::new();
63 self.encode(&mut ret);
64 ret
65 }
66
67 /// Read one of these from the front of `bytes` and
68 /// return it.
read_bytes(bytes: &[u8]) -> Option<Self>69 fn read_bytes(bytes: &[u8]) -> Option<Self> {
70 let mut rd = Reader::init(bytes);
71 Self::read(&mut rd)
72 }
73 }
74
75 // Encoding functions.
decode_u8(bytes: &[u8]) -> Option<u8>76 fn decode_u8(bytes: &[u8]) -> Option<u8> {
77 let [value]: [u8; 1] = bytes.try_into().ok()?;
78 Some(value)
79 }
80
81 impl Codec for u8 {
encode(&self, bytes: &mut Vec<u8>)82 fn encode(&self, bytes: &mut Vec<u8>) {
83 bytes.push(*self);
84 }
read(r: &mut Reader) -> Option<Self>85 fn read(r: &mut Reader) -> Option<Self> {
86 r.take(1).and_then(decode_u8)
87 }
88 }
89
put_u16(v: u16, out: &mut [u8])90 pub fn put_u16(v: u16, out: &mut [u8]) {
91 let out: &mut [u8; 2] = (&mut out[..2]).try_into().unwrap();
92 *out = u16::to_be_bytes(v);
93 }
94
decode_u16(bytes: &[u8]) -> Option<u16>95 pub fn decode_u16(bytes: &[u8]) -> Option<u16> {
96 Some(u16::from_be_bytes(bytes.try_into().ok()?))
97 }
98
99 impl Codec for u16 {
encode(&self, bytes: &mut Vec<u8>)100 fn encode(&self, bytes: &mut Vec<u8>) {
101 let mut b16 = [0u8; 2];
102 put_u16(*self, &mut b16);
103 bytes.extend_from_slice(&b16);
104 }
105
read(r: &mut Reader) -> Option<Self>106 fn read(r: &mut Reader) -> Option<Self> {
107 r.take(2).and_then(decode_u16)
108 }
109 }
110
111 // Make a distinct type for u24, even though it's a u32 underneath
112 #[allow(non_camel_case_types)]
113 #[derive(Debug, Copy, Clone)]
114 pub struct u24(pub u32);
115
116 impl u24 {
decode(bytes: &[u8]) -> Option<Self>117 pub fn decode(bytes: &[u8]) -> Option<Self> {
118 let [a, b, c]: [u8; 3] = bytes.try_into().ok()?;
119 Some(Self(u32::from_be_bytes([0, a, b, c])))
120 }
121 }
122
123 #[cfg(any(target_pointer_width = "32", target_pointer_width = "64"))]
124 impl From<u24> for usize {
125 #[inline]
from(v: u24) -> Self126 fn from(v: u24) -> Self {
127 v.0 as Self
128 }
129 }
130
131 impl Codec for u24 {
encode(&self, bytes: &mut Vec<u8>)132 fn encode(&self, bytes: &mut Vec<u8>) {
133 let be_bytes = u32::to_be_bytes(self.0);
134 bytes.extend_from_slice(&be_bytes[1..])
135 }
136
read(r: &mut Reader) -> Option<Self>137 fn read(r: &mut Reader) -> Option<Self> {
138 r.take(3).and_then(Self::decode)
139 }
140 }
141
decode_u32(bytes: &[u8]) -> Option<u32>142 pub fn decode_u32(bytes: &[u8]) -> Option<u32> {
143 Some(u32::from_be_bytes(bytes.try_into().ok()?))
144 }
145
146 impl Codec for u32 {
encode(&self, bytes: &mut Vec<u8>)147 fn encode(&self, bytes: &mut Vec<u8>) {
148 bytes.extend(&Self::to_be_bytes(*self))
149 }
150
read(r: &mut Reader) -> Option<Self>151 fn read(r: &mut Reader) -> Option<Self> {
152 r.take(4).and_then(decode_u32)
153 }
154 }
155
put_u64(v: u64, bytes: &mut [u8])156 pub fn put_u64(v: u64, bytes: &mut [u8]) {
157 let bytes: &mut [u8; 8] = (&mut bytes[..8]).try_into().unwrap();
158 *bytes = u64::to_be_bytes(v)
159 }
160
decode_u64(bytes: &[u8]) -> Option<u64>161 pub fn decode_u64(bytes: &[u8]) -> Option<u64> {
162 Some(u64::from_be_bytes(bytes.try_into().ok()?))
163 }
164
165 impl Codec for u64 {
encode(&self, bytes: &mut Vec<u8>)166 fn encode(&self, bytes: &mut Vec<u8>) {
167 let mut b64 = [0u8; 8];
168 put_u64(*self, &mut b64);
169 bytes.extend_from_slice(&b64);
170 }
171
read(r: &mut Reader) -> Option<Self>172 fn read(r: &mut Reader) -> Option<Self> {
173 r.take(8).and_then(decode_u64)
174 }
175 }
176
encode_vec_u8<T: Codec>(bytes: &mut Vec<u8>, items: &[T])177 pub fn encode_vec_u8<T: Codec>(bytes: &mut Vec<u8>, items: &[T]) {
178 let mut sub: Vec<u8> = Vec::new();
179 for i in items {
180 i.encode(&mut sub);
181 }
182
183 debug_assert!(sub.len() <= 0xff);
184 (sub.len() as u8).encode(bytes);
185 bytes.append(&mut sub);
186 }
187
encode_vec_u16<T: Codec>(bytes: &mut Vec<u8>, items: &[T])188 pub fn encode_vec_u16<T: Codec>(bytes: &mut Vec<u8>, items: &[T]) {
189 let mut sub: Vec<u8> = Vec::new();
190 for i in items {
191 i.encode(&mut sub);
192 }
193
194 debug_assert!(sub.len() <= 0xffff);
195 (sub.len() as u16).encode(bytes);
196 bytes.append(&mut sub);
197 }
198
encode_vec_u24<T: Codec>(bytes: &mut Vec<u8>, items: &[T])199 pub fn encode_vec_u24<T: Codec>(bytes: &mut Vec<u8>, items: &[T]) {
200 let mut sub: Vec<u8> = Vec::new();
201 for i in items {
202 i.encode(&mut sub);
203 }
204
205 debug_assert!(sub.len() <= 0xff_ffff);
206 u24(sub.len() as u32).encode(bytes);
207 bytes.append(&mut sub);
208 }
209
read_vec_u8<T: Codec>(r: &mut Reader) -> Option<Vec<T>>210 pub fn read_vec_u8<T: Codec>(r: &mut Reader) -> Option<Vec<T>> {
211 let mut ret: Vec<T> = Vec::new();
212 let len = usize::from(u8::read(r)?);
213 let mut sub = r.sub(len)?;
214
215 while sub.any_left() {
216 ret.push(T::read(&mut sub)?);
217 }
218
219 Some(ret)
220 }
221
read_vec_u16<T: Codec>(r: &mut Reader) -> Option<Vec<T>>222 pub fn read_vec_u16<T: Codec>(r: &mut Reader) -> Option<Vec<T>> {
223 let mut ret: Vec<T> = Vec::new();
224 let len = usize::from(u16::read(r)?);
225 let mut sub = r.sub(len)?;
226
227 while sub.any_left() {
228 ret.push(T::read(&mut sub)?);
229 }
230
231 Some(ret)
232 }
233
read_vec_u24_limited<T: Codec>(r: &mut Reader, max_bytes: usize) -> Option<Vec<T>>234 pub fn read_vec_u24_limited<T: Codec>(r: &mut Reader, max_bytes: usize) -> Option<Vec<T>> {
235 let mut ret: Vec<T> = Vec::new();
236 let len = u24::read(r)?.0 as usize;
237 if len > max_bytes {
238 return None;
239 }
240
241 let mut sub = r.sub(len)?;
242
243 while sub.any_left() {
244 ret.push(T::read(&mut sub)?);
245 }
246
247 Some(ret)
248 }
249