nt_packet/
lib.rs

1//! A crate containing base traits for interacting with NetworkTables packets in buffers
2//!
3//! This crate contains the traits core to `nt` and `nt-packet-derive` for reading and writing
4//! values (Packets or other complex values) to and from byte buffers from the `bytes` crate.
5//!
6//! This is not meant to be used alone, and is merely here so that `nt` and `nt-packet-derive` are able to share the same
7//! key traits.
8
9#![deny(missing_docs)]
10
11extern crate bytes;
12extern crate nt_leb128 as leb128;
13extern crate failure;
14
15mod ext;
16
17pub use self::ext::BufExt;
18
19use bytes::{Buf, BytesMut, BufMut};
20
21use leb128::write::LEB128Write;
22use leb128::read::LEB128Read;
23
24/// Trait representing an NT message/packet headed Client --> Server
25pub trait ClientMessage: Send {
26    /// Encodes `Self` into the given `buf`
27    fn encode(&self, buf: &mut BytesMut);
28}
29
30/// Trait representing an NT message/packet headed Server --> Client
31pub trait ServerMessage: Sized {
32    /// Attempts to decode `Self` from the given `buf`
33    /// Returns Some if the given `buf` was a valid NT packet
34    /// Returns None if the given `buf` was malformed, or otherwise invalid
35    fn decode(buf: &mut Buf) -> Result<(Self, usize), failure::Error>;
36}
37
38impl ClientMessage for String {
39    fn encode(&self, buf: &mut BytesMut) {
40        buf.write_unsigned(self.len() as u64).unwrap();
41        buf.put_slice(self.as_bytes());
42    }
43}
44
45impl ServerMessage for String {
46    fn decode(mut buf: &mut Buf) -> Result<(Self, usize), failure::Error> {
47        let (len, bytes_read) = buf.read_unsigned()?;
48        let len = len as usize;
49        let mut strbuf = vec![0; len];
50        buf.copy_to_slice(&mut strbuf[..]);
51        Ok((String::from_utf8(strbuf)?, len + bytes_read))
52    }
53}
54
55impl ClientMessage for Vec<u8> {
56    fn encode(&self, buf: &mut BytesMut) {
57        buf.write_unsigned(self.len() as u64).unwrap();
58        buf.extend_from_slice(&self[..]);
59    }
60}
61
62impl<T> ClientMessage for Vec<T>
63    where T: ClientMessage
64{
65    fn encode(&self, buf: &mut BytesMut) {
66        let mut bytes = BytesMut::new();
67        for item in self {
68            item.encode(&mut bytes);
69        }
70
71        buf.write_unsigned(bytes.len() as u64).unwrap();
72        buf.extend(bytes);
73    }
74}
75
76impl<T> ServerMessage for Vec<T>
77    where T: ServerMessage
78{
79    fn decode(mut buf: &mut Buf) -> Result<(Self, usize), failure::Error> {
80        let mut bytes_read = 0;
81        let len = {
82            let (len, bytes) = buf.read_unsigned()?;
83
84            bytes_read += bytes;
85
86            len as usize
87        };
88
89        let mut vec = Vec::with_capacity(len as usize);
90        for i in 0..len {
91            let (t, bytes) = T::decode(buf)?;
92            bytes_read += bytes;
93            vec[i as usize] = t;
94        }
95
96        Ok((vec, bytes_read))
97    }
98}
99
100impl ServerMessage for Vec<u8> {
101    fn decode(mut buf: &mut Buf) -> Result<(Self, usize), failure::Error> {
102        let mut bytes_read = 0;
103        let len = {
104            let (len, bytes) = buf.read_unsigned()?;
105
106            bytes_read += bytes;
107            len as usize
108        };
109        let mut vec = vec![0; len];
110
111        for i in 0..len {
112            vec[i] = buf.read_u8()?;
113            bytes_read += 1;
114        }
115
116        Ok((vec, bytes_read))
117    }
118}