Add a library for packet encoding/decoding in Rust.

common/rust-protocol/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "protocol"
+version = "0.1.0"
+authors = ["Mathias Gottschlag <mgottschlag@gmail.com>"]
+edition = "2018"
+
+[dependencies]
+crc16 = "0.4.0"
+xxtea-nostd = "0.1.0"

common/rust-protocol/src/lib.rs

@@ -0,0 +1,160 @@
+//! Library which implements serialization and deserialization for the packet format used by the
+//! base station and all sensor/display nodes.
+#![no_std]
+
+use core::convert::TryInto;
+
+use crc16::{State, KERMIT};
+use xxtea_nostd::decrypt;
+
+#[derive(Clone)]
+pub enum Packet {
+    Salt(u64),
+    Report(Report),
+    GetValues(GetValues),
+    Values(Values),
+}
+
+impl Packet {
+    pub fn decrypt_and_parse(key: &[u8], data: &mut [u8]) -> Option<Packet> {
+        decrypt_cbc(key, data);
+        let checksummed = &data[8..];
+        let calculated_crc = State::<KERMIT>::calculate(&checksummed);
+        let crc = u16::from_le_bytes(data[30..].try_into().unwrap());
+        if crc != calculated_crc {
+            return None;
+        }
+        Self::decode(&checksummed[..22])
+    }
+
+    fn decode(data: &[u8]) -> Option<Packet> {
+        let type_ = data[0] & 0x1f;
+        // count can be at most 7, so we do not need any checks when indexing 8-element arrays
+        // below.
+        let count = data[0] >> 5;
+        match type_ {
+            0 => Some(Self::Salt({
+                // The lowest 8 bit of the salt are the device ID and are filled in by the caller.
+                u64::from_le_bytes(data[1..9].try_into().unwrap()) << 8
+            })),
+            1 => Some(Self::Report(Report::decode(count, &data[1..])?)),
+            2 => Some(Self::GetValues(GetValues::decode(count, &data[1..])?)),
+            3 => Some(Self::Values(Values::decode(count, &data[1..])?)),
+            _ => None,
+        }
+    }
+}
+
+#[derive(Clone)]
+pub struct Report {
+    count: u8,
+    values: [Value; 8],
+}
+
+impl Report {
+    fn decode(count: u8, mut data: &[u8]) -> Option<Report> {
+        let mut report = Self {
+            count,
+            values: [Value::Invalid; 8],
+        };
+        for i in 0..count {
+            report.values[i as usize] = Value::decode(&mut data)?;
+        }
+        None
+    }
+}
+
+#[derive(Clone)]
+pub struct GetValues {
+    count: u8,
+    location: Location,
+    types_: [ValueType; 8],
+}
+
+impl GetValues {
+    fn decode(_count: u8, _data: &[u8]) -> Option<GetValues> {
+        // TODO
+        None
+    }
+}
+
+#[derive(Clone)]
+pub struct Values {
+    count: u8,
+    location: Location,
+    values: [Value; 8],
+}
+
+impl Values {
+    fn decode(_count: u8, _data: &[u8]) -> Option<Values> {
+        // TODO
+        None
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum Location {
+    Livingroom,
+    Bathroom,
+    Bedroom,
+    Kitchen,
+    Balcony,
+}
+
+#[derive(Clone, Copy)]
+pub enum Value {
+    Invalid,
+    Time(u64),
+    Temperature(i16),
+    Pressure(u32),
+    Humidity(u16),
+}
+
+impl Value {
+    fn decode(data: &mut &[u8]) -> Option<Value> {
+        let type_ = data[0];
+        let length = match type_ {
+            0 => 9,
+            1 => 3,
+            2 => 5,
+            3 => 3,
+            _ => return None,
+        };
+        if data.len() < length {
+            return None;
+        }
+        let result = match type_ {
+            0 => Self::Time(u64::from_le_bytes(data[1..9].try_into().unwrap())),
+            1 => Self::Temperature(i16::from_le_bytes(data[1..3].try_into().unwrap())),
+            2 => Self::Pressure(u32::from_le_bytes(data[1..5].try_into().unwrap())),
+            3 => Self::Humidity(u16::from_le_bytes(data[1..3].try_into().unwrap())),
+            _ => return None,
+        };
+        *data = &data[length..];
+        Some(result)
+    }
+}
+
+#[derive(Clone, Copy)]
+pub enum ValueType {
+    Time,
+    Temperature,
+    Pressure,
+    Humidity,
+}
+
+fn decrypt_cbc(key: &[u8], data: &mut [u8]) {
+    let mut blocks = data.rchunks_mut(8).peekable();
+    loop {
+        let block = blocks.next().unwrap();
+        let prev_block = match blocks.peek() {
+            Some(b) => b,
+            None => break,
+        };
+        decrypt(&key, block);
+
+        for i in 0..8 {
+            block[i] ^= prev_block[i];
+        }
+    }
+}