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