1pub trait MsgPack {
2 fn encode(&self, buf: &mut Vec<u8>);
3}
4
5use std::collections::BTreeMap;
6
7use byteorder::{BigEndian, WriteBytesExt};
8use smol_str::SmolStr;
9impl MsgPack for &str {
10 fn encode(&self, buf: &mut Vec<u8>) {
11 let length = self.len();
12 if length < 0x20 {
13 buf.push(0xa0 | length as u8);
14 } else if length < 0x100 {
15 buf.push(0xd9);
16 buf.push(length as u8);
17 } else if length < 0x10000 {
18 buf.push(0xda);
19 buf.write_u16::<BigEndian>(length as u16).unwrap();
20 } else {
21 buf.push(0xdb);
22 buf.write_u32::<BigEndian>(length as u32).unwrap();
23 }
24 buf.extend_from_slice(self.as_bytes());
25 }
26}
27
28impl MsgPack for i64 {
29 fn encode(&self, buf: &mut Vec<u8>) {
30 let value = *self;
31 if value >= 0 && value < 128 {
32 buf.push(value as u8);
33 } else if value < 0 && value > -32 {
34 let raw = (value as i8) as u8;
35 buf.push(raw);
36 } else {
37 if value >= -0x80 && value <= 0x7f {
38 buf.push(0xd0);
39 buf.write_i8(value as i8).unwrap();
40 } else if value >= -0x8000 && value <= 0x7fff {
41 buf.push(0xd1);
42 buf.write_i16::<BigEndian>(value as i16).unwrap();
43 } else if value >= -0x8000_0000 && value <= 0x7fff_ffff {
44 buf.push(0xd2);
45 buf.write_i32::<BigEndian>(value as i32).unwrap();
46 } else {
47 buf.push(0xd3);
48 buf.write_i64::<BigEndian>(value).unwrap();
49 }
50 }
51 }
52}
53
54use super::Dynamic;
55
56fn encode_bytes(raw: &[u8], buf: &mut Vec<u8>) {
57 let length = raw.len();
58 if length < 0x100 {
59 buf.push(0xc4);
60 buf.push(length as u8);
61 } else if length < 0x10000 {
62 buf.push(0xc5);
63 buf.write_u16::<BigEndian>(length as u16).unwrap();
64 } else {
65 buf.push(0xc6);
66 buf.write_u32::<BigEndian>(length as u32).unwrap();
67 }
68 buf.extend_from_slice(&raw);
69}
70
71fn encode_vec(raw: &[u8], len: usize, tag: u8, buf: &mut Vec<u8>) {
72 if len < 0x100 {
73 buf.push(0xc7);
74 buf.push(len as u8);
75 buf.push(tag);
76 } else if len < 0x10000 {
77 buf.push(0xc8);
78 buf.write_u16::<BigEndian>(len as u16).unwrap();
79 buf.push(tag);
80 } else {
81 buf.push(0xc9);
82 buf.write_u32::<BigEndian>(len as u32).unwrap();
83 buf.push(tag);
84 }
85 buf.extend_from_slice(raw);
86}
87
88impl MsgPack for Dynamic {
89 fn encode(&self, buf: &mut Vec<u8>) {
90 match self {
91 Dynamic::Iter { idx: _, keys: _, value: _ } => {}
92 Dynamic::Null => buf.push(0xc0),
93 Dynamic::Bool(b) => buf.push(if *b { 0xc3 } else { 0xc2 }),
94 Dynamic::I8(i) => (*i as i64).encode(buf),
95 Dynamic::I16(i) => (*i as i64).encode(buf),
96 Dynamic::I32(i) => (*i as i64).encode(buf),
97 Dynamic::I64(i) => (*i).encode(buf),
98 Dynamic::U8(i) => (*i as i64).encode(buf),
99 Dynamic::U16(i) => (*i as i64).encode(buf),
100 Dynamic::U32(i) => (*i as i64).encode(buf),
101 Dynamic::U64(i) => (*i as i64).encode(buf),
102 Dynamic::F32(f) => {
103 buf.push(0xca);
104 let int_value = f32::to_bits(*f);
105 buf.write_u32::<BigEndian>(int_value).unwrap();
106 }
107 Dynamic::F64(f) => {
108 buf.push(0xcb);
109 let int_value = f64::to_bits(*f);
110 buf.write_u64::<BigEndian>(int_value).unwrap();
111 }
112 Dynamic::String(s) => s.as_str().encode(buf),
113 Dynamic::Bytes(raw) => {
114 encode_bytes(raw.as_slice(), buf);
115 }
116 Dynamic::VecI8(vec) => {
117 let len = self.len();
118 encode_vec(vec.as_slice(), len, 1, buf);
119 }
120 Dynamic::VecU16(vec) => {
121 let len = self.len();
122 encode_vec(vec.as_slice(), len, 2, buf);
123 }
124 Dynamic::VecI16(vec) => {
125 let len = self.len();
126 encode_vec(vec.as_slice(), len, 3, buf);
127 }
128 Dynamic::VecU32(vec) => {
129 let len = self.len();
130 encode_vec(vec.as_slice(), len, 4, buf);
131 }
132 Dynamic::VecI32(vec) => {
133 let len = self.len();
134 encode_vec(vec.as_slice(), len, 5, buf);
135 }
136 Dynamic::VecF32(vec) => {
137 let len = self.len();
138 encode_vec(vec.as_slice(), len, 6, buf);
139 }
140 Dynamic::VecU64(vec) => {
141 let len = self.len();
142 encode_vec(bytemuck::cast_slice(vec.as_slice()), len, 7, buf);
143 }
144 Dynamic::VecI64(vec) => {
145 let len = self.len();
146 encode_vec(bytemuck::cast_slice(vec.as_slice()), len, 8, buf);
147 }
148 Dynamic::VecF64(vec) => {
149 let len = self.len();
150 encode_vec(bytemuck::cast_slice(vec.as_slice()), len, 9, buf);
151 }
152 Dynamic::List(raw) => {
153 let length = raw.read().unwrap().len();
154 if length < 0x10 {
155 buf.push(0x90 | length as u8);
156 } else if length < 0x10000 {
157 buf.push(0xdc);
158 buf.write_u16::<BigEndian>(length as u16).unwrap();
159 } else {
160 buf.push(0xdd);
161 buf.write_u32::<BigEndian>(length as u32).unwrap();
162 }
163 for item in raw.read().unwrap().iter() {
164 item.encode(buf);
165 }
166 }
167 Dynamic::Map(raw) => {
168 let length = raw.read().unwrap().len();
169 if length < 16 {
170 buf.push(0x80 | length as u8);
171 } else if length <= 0x10000 {
172 buf.push(0xde);
173 buf.write_u16::<BigEndian>(length as u16).unwrap();
174 } else {
175 buf.push(0xdf);
176 buf.write_u32::<BigEndian>(length as u32).unwrap();
177 }
178 for (k, v) in raw.read().unwrap().iter() {
179 k.as_str().encode(buf);
180 v.encode(buf);
181 }
182 }
183 Dynamic::Struct { .. } => {
184 let keys = self.keys();
185 let length = keys.len();
186 if length < 16 {
187 buf.push(0x80 | length as u8);
188 } else if length <= 0x10000 {
189 buf.push(0xde);
190 buf.write_u16::<BigEndian>(length as u16).unwrap();
191 } else {
192 buf.push(0xdf);
193 buf.write_u32::<BigEndian>(length as u32).unwrap();
194 }
195 for key in keys {
196 key.as_str().encode(buf);
197 self.get_dynamic(key.as_str()).unwrap_or(Dynamic::Null).encode(buf);
198 }
199 }
200 }
201 }
202}
203use anyhow::{Result, anyhow};
204
205pub trait MsgUnpack: Sized {
206 fn decode(buf: &[u8]) -> Result<(Self, usize)>;
207 fn decode_array(buf: &[u8], length: usize) -> Result<(Vec<Self>, usize)> {
208 let mut cursor = 0usize;
209 let mut result = Vec::with_capacity(length);
210 for _ in 0..length {
211 let (value, size) = Self::decode(&buf[cursor..])?;
212 result.push(value);
213 cursor += size;
214 }
215 Ok((result, cursor))
216 }
217}
218
219#[inline]
220pub(crate) fn read_8(raw: &[u8]) -> u8 {
221 raw[0]
222}
223
224#[inline]
225pub(crate) fn read_16(raw: &[u8]) -> u16 {
226 raw[1] as u16 | (raw[0] as u16) << 8
227}
228
229#[inline]
230pub(crate) fn read_32(raw: &[u8]) -> u32 {
231 raw[3] as u32 | (raw[2] as u32) << 8 | (raw[1] as u32) << 16 | (raw[0] as u32) << 24
232}
233
234#[inline]
235pub(crate) fn read_64(raw: &[u8]) -> u64 {
236 raw[7] as u64 | (raw[6] as u64) << 8 | (raw[5] as u64) << 16 | (raw[4] as u64) << 24 | (raw[3] as u64) << 32 | (raw[2] as u64) << 40 | (raw[1] as u64) << 48 | (raw[0] as u64) << 56
237}
238
239fn vec_to_map(kvs: Vec<Dynamic>) -> Result<Dynamic> {
240 let mut map: BTreeMap<SmolStr, Dynamic> = BTreeMap::new();
241 let mut key: Option<Dynamic> = None;
242 for kv in kvs {
243 if let Some(k) = key.take() {
244 map.insert(SmolStr::from(k.to_string()), kv);
245 } else {
246 key = Some(kv);
247 }
248 }
249 Ok(Dynamic::Map(Arc::new(RwLock::new(map))))
250}
251
252const TAG_LEN: [usize; 10] = [0, 1, 2, 2, 4, 4, 4, 8, 8, 8];
253
254use bytemuck::pod_collect_to_vec;
255
256fn to_vec(buf: &[u8], tag: u8) -> Result<Dynamic> {
257 match tag {
258 1 => Ok(Dynamic::from(bytemuck::cast_slice::<_, i8>(buf))),
259 2 => {
260 let aligned = pod_collect_to_vec::<_, u16>(buf);
261 Ok(Dynamic::from(aligned.as_slice()))
262 }
263 3 => {
264 let aligned = pod_collect_to_vec::<_, i16>(buf);
265 Ok(Dynamic::from(aligned.as_slice()))
266 }
267 4 => {
268 let aligned = pod_collect_to_vec::<_, u32>(buf);
269 Ok(Dynamic::from(aligned.as_slice()))
270 }
271 5 => {
272 let aligned = pod_collect_to_vec::<_, i32>(buf);
273 Ok(Dynamic::from(aligned.as_slice()))
274 }
275 6 => {
276 let aligned = pod_collect_to_vec::<_, f32>(buf);
277 Ok(Dynamic::from(aligned.as_slice()))
278 }
279 7 => {
280 let aligned = pod_collect_to_vec::<_, u64>(buf);
281 Ok(Dynamic::from(aligned.as_slice()))
282 }
283 8 => {
284 let aligned = pod_collect_to_vec::<_, i64>(buf);
285 Ok(Dynamic::from(aligned.as_slice()))
286 }
287 9 => {
288 let aligned = pod_collect_to_vec::<_, f64>(buf);
289 Ok(Dynamic::from(aligned.as_slice()))
290 }
291 _ => Err(anyhow!("unknow tag {}", tag)),
292 }
293}
294
295use std::sync::{Arc, RwLock};
296
297impl MsgUnpack for Dynamic {
298 fn decode(buf: &[u8]) -> Result<(Self, usize)> {
299 assert_err!(buf.len() < 1, anyhow!("no data"));
300 let first_byte = buf[0];
301 assert_ok!(first_byte <= 0x7f, (Dynamic::from(first_byte as i64), 1));
302 assert_ok!(first_byte >= 0xe0, (Dynamic::from(first_byte as i64 - 256), 1));
303 if first_byte >= 0x80 && first_byte <= 0x8f {
304 let len = (first_byte & 0x0f) as usize;
305 let (value, size) = Self::decode_array(&buf[1..], len * 2)?;
306 return vec_to_map(value).map(|r| (r, 1 + size));
307 }
308 if first_byte >= 0x90 && first_byte <= 0x9f {
309 let len = (first_byte & 0x0f) as usize;
310 let (value, size) = Self::decode_array(&buf[1..], len)?;
311 return Ok((Dynamic::List(Arc::new(RwLock::new(value))), 1 + size));
312 }
313
314 if first_byte >= 0xa0 && first_byte <= 0xbf {
315 let len = (first_byte & 0x1f) as usize;
316 assert_err!(buf.len() < 1 + len, anyhow!("no data"));
317 return Ok((Dynamic::from_utf8(&buf[1..1 + len])?, 1 + len));
318 }
319
320 assert_ok!(first_byte == 0xc0, (Dynamic::Null, 1));
321 assert_err!(first_byte == 0xc1, anyhow!("0xc1 never used"));
322 assert_ok!(first_byte == 0xc2, (false.into(), 1));
323 assert_ok!(first_byte == 0xc3, (true.into(), 1));
324
325 if first_byte == 0xc4 {
326 assert_err!(buf.len() < 2, anyhow!("no data"));
327 let len = read_8(&buf[1..]) as usize;
328 assert_err!(buf.len() < 2 + len, anyhow!("no data"));
329 return Ok((Dynamic::from(&buf[2..2 + len]), 2 + len));
330 }
331
332 if first_byte == 0xc5 {
333 assert_err!(buf.len() < 3, anyhow!("no data"));
334 let len = read_16(&buf[1..]) as usize;
335 assert_err!(buf.len() < 2 + len, anyhow!("no data"));
336 return Ok((Dynamic::from(&buf[3..3 + len]), 3 + len));
337 }
338
339 if first_byte == 0xc6 {
340 assert_err!(buf.len() < 5, anyhow!("no data"));
341 let len = read_32(&buf[1..]) as usize;
342 assert_err!(buf.len() < 5 + len, anyhow!("no data"));
343 return Ok((Dynamic::from(&buf[5..5 + len]), 5 + len));
344 }
345
346 if first_byte == 0xc7 {
347 assert_err!(buf.len() < 7, anyhow!("no data"));
348 let len = read_8(&buf[1..]) as usize;
349 let tag = read_8(&buf[2..]);
350 let byte_len = len * TAG_LEN[tag as usize];
351 return Ok((to_vec(&buf[3..3 + byte_len], tag)?, 3 + byte_len));
352 }
353
354 if first_byte == 0xc8 {
355 assert_err!(buf.len() < 8, anyhow!("no data"));
356 let len = read_16(&buf[1..]) as usize;
357 let tag = read_8(&buf[3..]);
358 let byte_len = len * TAG_LEN[tag as usize];
359 return Ok((to_vec(&buf[4..4 + byte_len], tag)?, 4 + byte_len));
360 }
361
362 if first_byte == 0xc9 {
363 assert_err!(buf.len() < 10, anyhow!("no data"));
364 let len = read_32(&buf[1..]) as usize;
365 let tag = read_8(&buf[5..]);
366 let byte_len = len * TAG_LEN[tag as usize];
367 return Ok((to_vec(&buf[6..6 + byte_len], tag)?, 6 + byte_len));
368 }
369
370 if first_byte == 0xca {
371 assert_err!(buf.len() < 5, anyhow!("no data"));
372 let raw_value = read_32(&buf[1..]) as u32;
373 let value = f32::from_bits(raw_value);
374 return Ok((Dynamic::from(value as f64), 5));
375 }
376
377 if first_byte == 0xcb {
378 assert_err!(buf.len() < 9, anyhow!("no data"));
379 let raw_value = read_64(&buf[1..]);
380 let value = f64::from_bits(raw_value);
381 return Ok((Dynamic::from(value), 9));
382 }
383
384 if first_byte == 0xd0 {
385 assert_err!(buf.len() < 2, anyhow!("no data"));
386 let raw_value = read_8(&buf[1..]);
387 let value = raw_value as i8 as i64;
388 return Ok((Dynamic::from(value), 2));
389 }
390
391 if first_byte == 0xcd {
392 assert_err!(buf.len() < 3, anyhow!("no data"));
393 let value = read_16(&buf[1..]);
394 return Ok((Dynamic::from(value as i64), 3));
395 }
396
397 if first_byte == 0xce {
398 assert_err!(buf.len() < 5, anyhow!("no data"));
399 let value = read_32(&buf[1..]);
400 return Ok((Dynamic::from(value as i64), 5));
401 }
402
403 if first_byte == 0xcf {
404 assert_err!(buf.len() < 9, anyhow!("no data"));
405 let value = read_64(&buf[1..]);
406 return Ok((Dynamic::from(value as i64), 9));
407 }
408
409 if first_byte == 0xd3 {
410 assert_err!(buf.len() < 9, anyhow!("no data"));
411 let raw_value = read_64(&buf[1..]);
412 let value = raw_value as i64;
413 return Ok((Dynamic::from(value), 9));
414 }
415
416 if first_byte == 0xd1 {
417 assert_err!(buf.len() < 3, anyhow!("no data"));
418 let raw_value = read_16(&buf[1..]);
419 let value = u16::cast_signed(raw_value) as i64;
420 return Ok((Dynamic::from(value), 3));
421 }
422
423 if first_byte == 0xd2 {
424 assert_err!(buf.len() < 5, anyhow!("no data"));
425 let raw_value = read_32(&buf[1..]);
426 let value = u32::cast_signed(raw_value) as i64;
427 return Ok((Dynamic::from(value), 5));
428 }
429
430 if first_byte == 0xd3 {
431 assert_err!(buf.len() < 9, anyhow!("no data"));
432 let raw_value = read_64(&buf[1..]);
433 let value = u64::cast_signed(raw_value);
434 return Ok((Dynamic::from(value), 9));
435 }
436
437 if first_byte == 0xd4 {
438 assert_err!(buf.len() < 3, anyhow!("no data"));
439 let _type_id = u8::cast_signed(buf[1]);
440 return Ok((Dynamic::Null, 3));
442 }
443
444 if first_byte == 0xd5 {
445 assert_err!(buf.len() < 4, anyhow!("no data"));
446 let _type_id = u8::cast_signed(buf[1]);
447 return Ok((Dynamic::Null, 4));
448 }
449
450 if first_byte == 0xd6 {
451 assert_err!(buf.len() < 6, anyhow!("no data"));
452 let _type_id = u8::cast_signed(buf[1]);
453 return Ok((Dynamic::Null, 6));
454 }
455
456 if first_byte == 0xd7 {
457 assert_err!(buf.len() < 10, anyhow!("no data"));
458 let _type_id = buf[1] as i8;
459 return Ok((Dynamic::Null, 10));
460 }
461
462 if first_byte == 0xd8 {
463 assert_err!(buf.len() < 18, anyhow!("no data"));
464 let _type_id = buf[1] as i8;
465 return Ok((Dynamic::Null, 18));
466 }
467
468 if first_byte == 0xd9 {
469 assert_err!(buf.len() < 2, anyhow!("no data"));
470 let len = read_8(&buf[1..]) as usize;
471 assert_err!(buf.len() < 2 + len, anyhow!("no data"));
472 return Ok((Dynamic::from_utf8(&buf[2..2 + len])?, 2 + len));
473 }
474
475 if first_byte == 0xda {
476 assert_err!(buf.len() < 3, anyhow!("no data"));
477 let len = read_16(&buf[1..]) as usize;
478 assert_err!(buf.len() < 3 + len, anyhow!("no data"));
479 return Ok((Dynamic::from_utf8(&buf[3..3 + len])?, 3 + len));
480 }
481
482 if first_byte == 0xdb {
483 assert_err!(buf.len() < 5, anyhow!("no data"));
484 let len = read_32(&buf[1..]) as usize;
485 assert_err!(buf.len() < 5 + len, anyhow!("no data"));
486 return Ok((Dynamic::from_utf8(&buf[5..5 + len])?, 5 + len));
487 }
488
489 if first_byte == 0xdc {
490 assert_err!(buf.len() < 3, anyhow!("no data"));
491 let len = read_16(&buf[1..]) as usize;
492 let (value, size) = Self::decode_array(&buf[3..], len)?;
493 return Ok((Dynamic::List(Arc::new(RwLock::new(value))), 3 + size));
494 }
495
496 if first_byte == 0xdd {
497 assert_err!(buf.len() < 5, anyhow!("no data"));
498 let len = read_32(&buf[1..]) as usize;
499 let (value, size) = Self::decode_array(&buf[5..], len)?;
500 return Ok((Dynamic::List(Arc::new(RwLock::new(value))), 5 + size));
501 }
502
503 if first_byte == 0xde {
504 assert_err!(buf.len() < 3, anyhow!("no data"));
505 let len = read_16(&buf[1..]) as usize;
506 let (value, size) = Self::decode_array(&buf[3..], len * 2)?;
507 return vec_to_map(value).map(|r| (r, 3 + size));
508 }
509
510 if first_byte == 0xdf {
511 assert_err!(buf.len() < 5, anyhow!("no data"));
512 let len = read_32(&buf[1..]) as usize;
513 let (value, size) = Self::decode_array(&buf[5..], len * 2)?;
514 return vec_to_map(value).map(|r| (r, 5 + size));
515 }
516 Err(anyhow!("error code {}", first_byte))
517 }
518}