Compare revisions

Stephen D · Stephen D · Stephen D · Stephen D · Stephen D · Stephen D
--- a/.gitlab-ci.yml
+++ b/.gitlab-ci.yml
+image: "rust:latest"
+
+before_script:
+  - rustup component add rustfmt
+  - rustup component add clippy
+
+test:
+  script:
+    - cargo fmt -- --check
+    - cargo clippy --all-targets --all-features -- -D warnings
+    - cargo test
--- a/Cargo.toml
+++ b/Cargo.toml
 [package]
 name = "ham-cats"
-version = "0.1.0"
+version = "0.2.2"
 edition = "2021"
 license = "MIT"
-
-# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
+description = "Reference implementations for CATS, the ham radio protocol"
+repository = "https://gitlab.scd31.com/cats/ham_cats"
+homepage = "https://cats.radio"
+categories = ["embedded", "encoding", "no-std", "no-std::no-alloc"]

 [dependencies]
 arrayvec = { version = "0.7.4", default-features = false }
+bitvec = { version = "1.0.1", default-features = false }
 crc = "3.0.1"
 encoding_rs = { version = "0.8.33", default-features = false }
 half = { version = "2.3.1", default-features = false }
-snafu = "0.7.5"
+labrador-ldpc = "1.2.1"
+paste = "1.0.14"
+snafu = { version = "0.7.5", default-features = false }
--- a/LICENSE.md
+++ b/LICENSE.md
+The MIT License (MIT)
+=====================
+
+Copyright © 2023 CATS
+
+Permission is hereby granted, free of charge, to any person
+obtaining a copy of this software and associated documentation
+files (the “Software”), to deal in the Software without
+restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the
+Software is furnished to do so, subject to the following
+conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+OTHER DEALINGS IN THE SOFTWARE.
+
--- a/fuzz/.gitignore
+++ b/fuzz/.gitignore
+target
+corpus
+artifacts
--- a/fuzz/Cargo.lock
+++ b/fuzz/Cargo.lock
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 3
+
+[[package]]
+name = "arbitrary"
+version = "1.3.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e2d098ff73c1ca148721f37baad5ea6a465a13f9573aba8641fbbbae8164a54e"
+
+[[package]]
+name = "arrayvec"
+version = "0.7.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "96d30a06541fbafbc7f82ed10c06164cfbd2c401138f6addd8404629c4b16711"
+
+[[package]]
+name = "bitvec"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1bc2832c24239b0141d5674bb9174f9d68a8b5b3f2753311927c172ca46f7e9c"
+dependencies = [
+ "funty",
+ "radium",
+ "tap",
+ "wyz",
+]
+
+[[package]]
+name = "cc"
+version = "1.0.83"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f1174fb0b6ec23863f8b971027804a42614e347eafb0a95bf0b12cdae21fc4d0"
+dependencies = [
+ "jobserver",
+ "libc",
+]
+
+[[package]]
+name = "cfg-if"
+version = "1.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "baf1de4339761588bc0619e3cbc0120ee582ebb74b53b4efbf79117bd2da40fd"
+
+[[package]]
+name = "crc"
+version = "3.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "86ec7a15cbe22e59248fc7eadb1907dab5ba09372595da4d73dd805ed4417dfe"
+dependencies = [
+ "crc-catalog",
+]
+
+[[package]]
+name = "crc-catalog"
+version = "2.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cace84e55f07e7301bae1c519df89cdad8cc3cd868413d3fdbdeca9ff3db484"
+
+[[package]]
+name = "crunchy"
+version = "0.2.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7a81dae078cea95a014a339291cec439d2f232ebe854a9d672b796c6afafa9b7"
+
+[[package]]
+name = "doc-comment"
+version = "0.3.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "fea41bba32d969b513997752735605054bc0dfa92b4c56bf1189f2e174be7a10"
+
+[[package]]
+name = "encoding_rs"
+version = "0.8.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7268b386296a025e474d5140678f75d6de9493ae55a5d709eeb9dd08149945e1"
+dependencies = [
+ "cfg-if",
+]
+
+[[package]]
+name = "funty"
+version = "2.0.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e6d5a32815ae3f33302d95fdcb2ce17862f8c65363dcfd29360480ba1001fc9c"
+
+[[package]]
+name = "half"
+version = "2.3.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "bc52e53916c08643f1b56ec082790d1e86a32e58dc5268f897f313fbae7b4872"
+dependencies = [
+ "cfg-if",
+ "crunchy",
+]
+
+[[package]]
+name = "ham-cats"
+version = "0.2.0"
+dependencies = [
+ "arrayvec",
+ "bitvec",
+ "crc",
+ "encoding_rs",
+ "half",
+ "labrador-ldpc",
+ "paste",
+ "snafu",
+]
+
+[[package]]
+name = "ham-cats-fuzz"
+version = "0.0.0"
+dependencies = [
+ "ham-cats",
+ "libfuzzer-sys",
+]
+
+[[package]]
+name = "heck"
+version = "0.4.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "95505c38b4572b2d910cecb0281560f54b440a19336cbbcb27bf6ce6adc6f5a8"
+
+[[package]]
+name = "jobserver"
+version = "0.1.26"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "936cfd212a0155903bcbc060e316fb6cc7cbf2e1907329391ebadc1fe0ce77c2"
+dependencies = [
+ "libc",
+]
+
+[[package]]
+name = "labrador-ldpc"
+version = "1.1.1"
+
+[[package]]
+name = "libc"
+version = "0.2.148"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9cdc71e17332e86d2e1d38c1f99edcb6288ee11b815fb1a4b049eaa2114d369b"
+
+[[package]]
+name = "libfuzzer-sys"
+version = "0.4.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a96cfd5557eb82f2b83fed4955246c988d331975a002961b07c81584d107e7f7"
+dependencies = [
+ "arbitrary",
+ "cc",
+ "once_cell",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.18.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dd8b5dd2ae5ed71462c540258bedcb51965123ad7e7ccf4b9a8cafaa4a63576d"
+
+[[package]]
+name = "paste"
+version = "1.0.14"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "de3145af08024dea9fa9914f381a17b8fc6034dfb00f3a84013f7ff43f29ed4c"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.67"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3d433d9f1a3e8c1263d9456598b16fec66f4acc9a74dacffd35c7bb09b3a1328"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.33"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5267fca4496028628a95160fc423a33e8b2e6af8a5302579e322e4b520293cae"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "radium"
+version = "0.7.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "dc33ff2d4973d518d823d61aa239014831e521c75da58e3df4840d3f47749d09"
+
+[[package]]
+name = "snafu"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "e4de37ad025c587a29e8f3f5605c00f70b98715ef90b9061a815b9e59e9042d6"
+dependencies = [
+ "doc-comment",
+ "snafu-derive",
+]
+
+[[package]]
+name = "snafu-derive"
+version = "0.7.5"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "990079665f075b699031e9c08fd3ab99be5029b96f3b78dc0709e8f77e4efebf"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "syn"
+version = "1.0.109"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "72b64191b275b66ffe2469e8af2c1cfe3bafa67b529ead792a6d0160888b4237"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "tap"
+version = "1.0.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "55937e1799185b12863d447f42597ed69d9928686b8d88a1df17376a097d8369"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.12"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "3354b9ac3fae1ff6755cb6db53683adb661634f67557942dea4facebec0fee4b"
+
+[[package]]
+name = "wyz"
+version = "0.5.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "05f360fc0b24296329c78fda852a1e9ae82de9cf7b27dae4b7f62f118f77b9ed"
+dependencies = [
+ "tap",
+]
--- a/fuzz/Cargo.toml
+++ b/fuzz/Cargo.toml
+[package]
+name = "ham-cats-fuzz"
+version = "0.0.0"
+authors = ["Automatically generated"]
+publish = false
+edition = "2018"
+
+[package.metadata]
+cargo-fuzz = true
+
+[dependencies]
+libfuzzer-sys = "0.4"
+
+[dependencies.ham-cats]
+path = ".."
+
+# Prevent this from interfering with workspaces
+[workspace]
+members = ["."]
+
+[[bin]]
+name = "fuzz_target_1"
+path = "fuzz_targets/fuzz_target_1.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_target_2"
+path = "fuzz_targets/fuzz_target_2.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_target_3"
+path = "fuzz_targets/fuzz_target_3.rs"
+test = false
+doc = false
+
+[[bin]]
+name = "fuzz_target_4"
+path = "fuzz_targets/fuzz_target_4.rs"
+test = false
+doc = false
--- a/fuzz/fuzz_targets/fuzz_target_1.rs
+++ b/fuzz/fuzz_targets/fuzz_target_1.rs
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+
+use ham_cats::packet::Packet;
+
+fuzz_target!(|data: &[u8]| {
+    let mut buf = [0; 1024];
+
+    let _ = Packet::<1024>::fully_decode(data, &mut buf);
+});
--- a/fuzz/fuzz_targets/fuzz_target_2.rs
+++ b/fuzz/fuzz_targets/fuzz_target_2.rs
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+
+use ham_cats::{buffer::Buffer, packet::Packet};
+
+fuzz_target!(|data: &[u8]| {
+    let mut buf = [0; 1024];
+    let mut buf = Buffer::new_empty(&mut buf);
+    if buf.try_extend_from_slice(data).is_ok() {
+        let _ = Packet::<1024>::semi_decode(buf);
+    }
+});
--- a/fuzz/fuzz_targets/fuzz_target_3.rs
+++ b/fuzz/fuzz_targets/fuzz_target_3.rs
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+
+use ham_cats::{buffer::Buffer, packet::Packet};
+
+fuzz_target!(|data: &[u8]| {
+    let mut buf = [0; 1024];
+    let mut buf = Buffer::new_empty(&mut buf);
+    if buf.try_extend_from_slice(data).is_ok() {
+        let _ = Packet::<1024>::decode(buf);
+    }
+});
--- a/fuzz/fuzz_targets/fuzz_target_4.rs
+++ b/fuzz/fuzz_targets/fuzz_target_4.rs
+#![no_main]
+use libfuzzer_sys::fuzz_target;
+
+use ham_cats::packet::Packet;
+use std::convert::TryInto;
+
+fuzz_target!(|data: &[u8]| {
+    // [u8] -> [i8]
+    let mut data: Vec<_> = data
+        .iter()
+        .map(|x| (u16::from(*x) as i16 - 128).try_into().unwrap())
+        .collect();
+
+    let mut buf = [0; 1024];
+    let _ = Packet::<1024>::fully_decode_soft::<8192, i8>(&mut data, &mut buf);
+});
--- a/src/buffer.rs
+++ b/src/buffer.rs
+use core::ops::{Deref, DerefMut};
+
+#[derive(Debug)]
+pub struct BufferOverflow;
+
+#[derive(Debug)]
+pub struct Buffer<'a, const N: usize, T = u8> {
+    data: &'a mut [T; N],
+    i: usize,
+}
+
+impl<'a, const N: usize, T: Copy> Buffer<'a, N, T> {
+    /// Constructs a new `Buffer`.
+    /// `data` is the backing array.
+    /// `i` is the number of elements in `data` that contain data (and should thus be exposed by `Buffer`)
+    pub fn new(data: &'a mut [T; N], i: usize) -> Self {
+        assert!(i <= data.len());
+
+        Self { data, i }
+    }
+
+    pub fn new_full(data: &'a mut [T; N]) -> Self {
+        let i = data.len();
+
+        Self::new(data, i)
+    }
+
+    pub fn new_empty(data: &'a mut [T; N]) -> Self {
+        Self::new(data, 0)
+    }
+
+    pub const fn remaining_capacity(&self) -> usize {
+        N - self.i
+    }
+
+    pub fn try_push(&mut self, v: T) -> Result<(), BufferOverflow> {
+        if self.i == N {
+            return Err(BufferOverflow);
+        }
+
+        self.data[self.i] = v;
+        self.i += 1;
+
+        Ok(())
+    }
+
+    pub fn push(&mut self, v: T) {
+        self.try_push(v).unwrap();
+    }
+
+    pub fn try_extend_from_slice(&mut self, other: &[T]) -> Result<(), BufferOverflow> {
+        if self.remaining_capacity() < other.len() {
+            return Err(BufferOverflow);
+        }
+
+        self.data[self.i..(self.i + other.len())].copy_from_slice(other);
+        self.i += other.len();
+
+        Ok(())
+    }
+
+    pub fn extend(&mut self, other: &[T]) {
+        self.try_extend_from_slice(other).unwrap();
+    }
+
+    pub fn pop(&mut self) -> Option<T> {
+        if self.i == 0 {
+            return None;
+        }
+
+        self.i -= 1;
+
+        Some(self.data[self.i])
+    }
+
+    pub fn truncate(&mut self, new_len: usize) {
+        assert!(self.i >= new_len);
+
+        self.i = new_len;
+    }
+
+    pub fn drain(&mut self, start: usize, end: usize) {
+        assert!(end >= start);
+        assert!(end <= self.i);
+        let delta = end - start;
+        let surplus = self.len() - end;
+
+        for i in start..(start + surplus) {
+            self[i] = self[i + delta];
+        }
+
+        self.i -= delta;
+    }
+
+    pub fn clone_backing<'b>(&self, buf: &'b mut [T; N]) -> Buffer<'b, N, T> {
+        let mut out = Buffer::new_empty(buf);
+
+        out.extend(self);
+
+        out
+    }
+}
+
+impl<'a, const N: usize, T> From<&'a mut [T; N]> for Buffer<'a, N, T> {
+    fn from(data: &'a mut [T; N]) -> Self {
+        Self { data, i: 0 }
+    }
+}
+
+impl<const N: usize, T> Deref for Buffer<'_, N, T> {
+    type Target = [T];
+
+    fn deref(&self) -> &Self::Target {
+        &self.data[..self.i]
+    }
+}
+
+impl<const N: usize, T> DerefMut for Buffer<'_, N, T> {
+    fn deref_mut(&mut self) -> &mut [T] {
+        &mut self.data[..self.i]
+    }
+}
--- a/src/error.rs
+++ b/src/error.rs
@@ -16,6 +16,12 @@ pub enum DecodeError {

    #[snafu(display("CRC checksum mismatch"))]
    CrcMismatch,
+
+    #[snafu(display("LDPC Decode error"))]
+    LdpcError,
+
+    #[snafu(display("Given data does not fit in the CATS packet"))]
+    Overflow,
 }

 #[derive(Debug, Snafu)]
@@ -26,3 +32,57 @@ pub enum EncodeError {
    #[snafu(display("Given data causes CATS packet to overflow"))]
    CatsOverflow,
 }
+
+#[derive(Debug, Snafu)]
+pub enum CommentError {
+    #[snafu(display("CATS packet does not have comment data"))]
+    NoComment,
+
+    #[snafu(display("Given buffer too small for comment data"))]
+    BufferOverflow,
+}
+
+#[derive(Debug, Snafu)]
+pub enum DigipeatError {
+    #[snafu(display("No route"))]
+    NoRoute,
+
+    #[snafu(display("Identification is us"))]
+    Us,
+
+    #[snafu(display("Max hops hit"))]
+    MaxHops,
+
+    #[snafu(display("Already digipeated by this node"))]
+    AlreadyDigipeated,
+
+    #[snafu(display("Future hop(s) are already set"))]
+    SetDestiny,
+}
+
+#[derive(Debug, Snafu, PartialEq, Eq)]
+pub enum AppendNodeError {
+    #[snafu(display("Future hop(s) already set to a different node"))]
+    SetFuture,
+
+    #[snafu(display("Max hops hit"))]
+    HopsOverflow,
+
+    #[snafu(display("Node already in route"))]
+    DuplicateNode,
+
+    #[snafu(display("Given data causes the route whisker to overflow"))]
+    RouteOverflow,
+}
+
+#[derive(Debug, Snafu, PartialEq, Eq)]
+pub enum PacketRouteAppendError {
+    #[snafu(display("No route whisker on packet"))]
+    NoRouteWhisker,
+
+    #[snafu(display("Route error"))]
+    Route { error: AppendNodeError },
+
+    #[snafu(display("CATS packet overflow"))]
+    PacketOverflow,
+}
--- a/src/identity.rs
+++ b/src/identity.rs
+#[derive(Debug, Eq, PartialEq, Copy, Clone)]
+pub struct Identity<'a> {
+    callsign: &'a str,
+    ssid: u8,
+}
+
+impl<'a> Identity<'a> {
+    pub fn new(callsign: &'a str, ssid: u8) -> Self {
+        Self { callsign, ssid }
+    }
+
+    pub fn callsign(&self) -> &'a str {
+        self.callsign
+    }
+
+    pub fn ssid(&self) -> u8 {
+        self.ssid
+    }
+}
--- a/src/interleaver.rs
+++ b/src/interleaver.rs
+use bitvec::prelude::*;
+use labrador_ldpc::decoder::DecodeFrom;
+
+use crate::{
+    buffer::{Buffer, BufferOverflow},
+    error::EncodeError,
+};
+
+pub(crate) fn interleave<const N: usize>(
+    data: &[u8],
+    out: &mut Buffer<N>,
+) -> Result<(), EncodeError> {
+    let bv = data.view_bits::<Msb0>();
+
+    let initial_length = out.len();
+    for _ in 0..data.len() {
+        out.try_push(0).map_err(|_| EncodeError::CatsOverflow)?;
+    }
+    let bv_out = out[initial_length..].view_bits_mut::<Msb0>();
+
+    let mut out_i = 0;
+    for i in 0..32 {
+        for j in (0..bv.len()).step_by(32) {
+            if i + j >= bv.len() {
+                continue;
+            }
+
+            bv_out.set(out_i, bv[i + j]);
+
+            out_i += 1;
+        }
+    }
+
+    Ok(())
+}
+
+pub(crate) fn uninterleave<const N: usize>(
+    data: &[u8],
+    out: &mut Buffer<N>,
+) -> Result<(), BufferOverflow> {
+    let bv = data.view_bits::<Msb0>();
+
+    for _ in 0..data.len() {
+        out.try_push(0)?;
+    }
+    let bv_out = out.view_bits_mut::<Msb0>();
+
+    let mut out_i = 0;
+    for i in 0..32 {
+        for j in (0..bv.len()).step_by(32) {
+            if i + j >= bv.len() {
+                continue;
+            }
+
+            bv_out.set(i + j, bv[out_i]);
+
+            out_i += 1;
+        }
+    }
+
+    Ok(())
+}
+
+pub(crate) fn uninterleave_soft<const N: usize, T: DecodeFrom>(
+    data: &[T],
+    out: &mut Buffer<N, T>,
+) -> Result<(), BufferOverflow> {
+    for _ in 0..data.len() {
+        out.try_push(T::zero())?;
+    }
+
+    let mut out_i = 0;
+    for i in 0..32 {
+        for j in (0..data.len()).step_by(32) {
+            if i + j >= data.len() {
+                continue;
+            }
+
+            out[i + j] = data[out_i];
+
+            out_i += 1;
+        }
+    }
+
+    Ok(())
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::soft_bit::FromHardBit;
+
+    #[test]
+    fn interleaver_works() {
+        let mut data = [0x84, 0x73, 0x12, 0xA3, 0xFF, 0x00, 0xC2, 0x1B, 0x77];
+        let orig = Buffer::new_full(&mut data);
+
+        let mut interleaved = [0; 10];
+        let mut interleaved = Buffer::new(&mut interleaved, 0);
+        interleaved.push(b'H');
+
+        interleave(&orig, &mut interleaved).unwrap();
+
+        let expected = [b'H', 0xCD, 0xB5, 0xDB, 0x2A, 0x0A, 0x52, 0x0C, 0x89, 0x4F];
+        assert_eq!(expected, interleaved[..]);
+
+        let mut uninterleaved = [0; 10];
+        let mut uninterleaved = Buffer::new(&mut uninterleaved, 0);
+        uninterleave(&interleaved[1..], &mut uninterleaved).unwrap();
+
+        assert_eq!(*orig, *uninterleaved);
+    }
+
+    #[test]
+    fn hard_interleave_soft_uninterleave() {
+        let mut data = [0x84, 0x73, 0x12, 0xA3, 0xFF, 0x00, 0xC2, 0x1B, 0x77];
+        let orig = Buffer::new_full(&mut data);
+
+        let mut interleaved = [0; 10];
+        let mut interleaved = Buffer::new(&mut interleaved, 0);
+        interleaved.push(b'H');
+
+        interleave(&orig, &mut interleaved).unwrap();
+
+        let mut soft_interleaved = [0.0; 10 * 8];
+        for (i, b) in interleaved.iter().enumerate() {
+            for j in 0..8 {
+                soft_interleaved[8 * i + j] = f32::from_hard_bit(b & (1 << (7 - j)) > 0);
+            }
+        }
+
+        let mut uninterleaved = [0.0; 10 * 8];
+        let mut uninterleaved = Buffer::new(&mut uninterleaved, 0);
+        uninterleave_soft(&soft_interleaved[8..], &mut uninterleaved).unwrap();
+
+        assert_eq!(orig.len() * 8, uninterleaved.len());
+        for (i, b) in orig.iter().enumerate() {
+            for j in 0..8 {
+                assert_eq!(uninterleaved[8 * i + j].hard_bit(), *b & (1 << (7 - j)) > 0);
+            }
+        }
+    }
+}
--- a/src/ldpc.rs
+++ b/src/ldpc.rs
+use labrador_ldpc::{decoder::DecodeFrom, LDPCCode};
+
+use crate::{buffer::Buffer, error::EncodeError};
+
+macro_rules! enc_chunk {
+    ($d:ident, $i:ident, $t:ident, $n:literal) => {
+        ::paste::paste! {
+        let mut codeword = [0; $n * 2];
+        codeword[0..$n].copy_from_slice(&$d[$i..($i + $n)]);
+        labrador_ldpc::LDPCCode::[<$t>].encode(&mut codeword);
+        $d.try_extend_from_slice(&codeword[$n..])
+            .map_err(|_| EncodeError::CatsOverflow)?;
+
+            $i += $n;
+        }
+    };
+}
+
+macro_rules! dec_chunk {
+    ($d:ident, $p:ident, $w:ident, $t:ident, $n:literal) => {
+        ::paste::paste! {
+            let code_data = &mut $d[..$n];
+            let code_parity = &$p.get_mut(..$n)?;
+
+            let mut input = [0; $n * 2];
+            input[..$n].copy_from_slice(code_data);
+            input[$n..].copy_from_slice(code_parity);
+            const CODE: LDPCCode = LDPCCode::[<$t>];
+            let mut out = [0; CODE.output_len()];
+            CODE.decode_bf(&input, &mut out, &mut $w[..CODE.decode_bf_working_len()], 16);
+            code_data.copy_from_slice(&out[..$n]);
+
+            $d = &mut $d[$n..];
+            $p = &mut $p[$n..];
+        }
+    };
+}
+
+macro_rules! dec_chunk_soft {
+    ($d:ident, $p:ident, $w:ident, $w_u8:ident, $out:ident, $t:ident, $n:literal) => {
+        ::paste::paste! {
+            let code_data = &mut $d[..$n];
+            let code_parity = &$p.get_mut(..$n)?;
+
+            let mut input = [T::zero(); $n * 2];
+            input[..$n].copy_from_slice(code_data);
+            input[$n..].copy_from_slice(code_parity);
+            const CODE: LDPCCode = LDPCCode::[<$t>];
+
+			let mut out_tmp = [0; CODE.output_len()];
+            CODE.decode_ms(&input, &mut out_tmp, &mut $w[..CODE.decode_ms_working_len()], &mut $w_u8[..CODE.decode_ms_working_u8_len()], 16);
+			$out.try_extend_from_slice(&out_tmp[..$n/8]).ok()?;
+
+            $d = &mut $d[$n..];
+            $p = &mut $p[$n..];
+        }
+    };
+}
+
+// On failure this still modifies the data array!
+pub(crate) fn encode<const N: usize>(data: &mut Buffer<N>) -> Result<(), EncodeError> {
+    let mut i = 0;
+    let n = data.len();
+
+    loop {
+        match n - i {
+            512.. => {
+                enc_chunk!(data, i, TM8192, 512);
+            }
+
+            128.. => {
+                enc_chunk!(data, i, TM2048, 128);
+            }
+
+            32.. => {
+                enc_chunk!(data, i, TC512, 32);
+            }
+
+            16.. => {
+                enc_chunk!(data, i, TC256, 16);
+            }
+
+            8.. => {
+                enc_chunk!(data, i, TC128, 8);
+            }
+
+            0 => break,
+
+            _ => {
+                let mut codeword = [0xAA; 16];
+                codeword[0..(n - i)].copy_from_slice(&data[i..n]);
+                LDPCCode::TC128.encode(&mut codeword);
+                data.try_extend_from_slice(&codeword[8..])
+                    .map_err(|_| EncodeError::CatsOverflow)?;
+
+                i = n;
+            }
+        }
+    }
+
+    data.try_extend_from_slice(&u16::try_from(n).unwrap().to_le_bytes())
+        .map_err(|_| EncodeError::CatsOverflow)?;
+
+    Ok(())
+}
+
+pub(crate) fn decode<const N: usize>(data_av: &mut Buffer<N>) -> Option<()> {
+    if data_av.len() < 2 {
+        return None;
+    }
+
+    let len = [data_av[data_av.len() - 2], data_av[data_av.len() - 1]];
+    let len = u16::from_le_bytes(len).into();
+
+    if len >= data_av.len() {
+        return None;
+    }
+
+    let (mut data, parity) = data_av.split_at_mut(len);
+    let mut parity = parity.get_mut(..parity.len().checked_sub(2)?)?;
+
+    let mut working = [0; LDPCCode::TM8192.decode_bf_working_len()];
+
+    loop {
+        match data.len() {
+            512.. => {
+                dec_chunk!(data, parity, working, TM8192, 512);
+            }
+
+            128.. => {
+                dec_chunk!(data, parity, working, TM2048, 128);
+            }
+
+            32.. => {
+                dec_chunk!(data, parity, working, TC512, 32);
+            }
+
+            16.. => {
+                dec_chunk!(data, parity, working, TC256, 16);
+            }
+
+            8.. => {
+                dec_chunk!(data, parity, working, TC128, 8);
+            }
+
+            0 => break,
+
+            _ => {
+                let mut code_data = [0xAA; 8];
+                code_data[..data.len()].copy_from_slice(data);
+                let code_parity = &parity.get_mut(..8)?;
+
+                let mut input = [0; 16];
+                input[..8].copy_from_slice(&code_data);
+                input[8..].copy_from_slice(code_parity);
+                let mut out = [0; LDPCCode::TC128.output_len()];
+                LDPCCode::TC128.decode_bf(
+                    &input,
+                    &mut out,
+                    &mut working[..LDPCCode::TC128.decode_bf_working_len()],
+                    16,
+                );
+                data.copy_from_slice(&out[..data.len()]);
+
+                data = &mut data[..0];
+                parity = &mut parity[..0];
+            }
+        }
+    }
+
+    // remove the parity data
+    data_av.truncate(len);
+
+    Some(())
+}
+
+pub(crate) fn decode_soft<const N: usize, const M: usize, T: DecodeFrom>(
+    data_av: &mut Buffer<N, T>,
+    out: &mut Buffer<M>,
+) -> Option<()> {
+    if data_av.len() % 8 != 0 {
+        return None;
+    }
+
+    if data_av.len() < 16 {
+        return None;
+    }
+
+    let len: usize = len_from_soft(data_av[(data_av.len() - 16)..].try_into().unwrap()).into();
+
+    if len * 8 + 16 >= data_av.len() {
+        return None;
+    }
+
+    let data_len = data_av.len().checked_sub(16)?;
+    let data_av = data_av.get_mut(..data_len)?;
+
+    let (mut data, mut parity) = data_av.split_at_mut(len * 8);
+
+    let mut working = [T::zero(); LDPCCode::TM8192.decode_ms_working_len()];
+    let mut working_u8 = [0; LDPCCode::TM8192.decode_ms_working_u8_len()];
+
+    loop {
+        match data.len() {
+            4096.. => {
+                dec_chunk_soft!(data, parity, working, working_u8, out, TM8192, 4096);
+            }
+
+            1024.. => {
+                dec_chunk_soft!(data, parity, working, working_u8, out, TM2048, 1024);
+            }
+
+            256.. => {
+                dec_chunk_soft!(data, parity, working, working_u8, out, TC512, 256);
+            }
+
+            128.. => {
+                dec_chunk_soft!(data, parity, working, working_u8, out, TC256, 128);
+            }
+
+            64.. => {
+                dec_chunk_soft!(data, parity, working, working_u8, out, TC128, 64);
+            }
+
+            0 => break,
+
+            _ => {
+                // Extra bits are padded with 0xAA
+                // We need to tell the soft decoder that these bits can't have flipped
+                // So we use T::maxval
+                let mut code_data = [
+                    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
+                    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
+                    1, 0, 1, 0, 1, 0, 1, 0, 1, 0, 1, 0,
+                ]
+                .map(|x| if x > 0 { -T::maxval() } else { T::maxval() });
+                code_data[..data.len()].copy_from_slice(data);
+                let code_parity = &parity.get_mut(..64)?;
+
+                let mut input = [T::zero(); 128];
+                input[..64].copy_from_slice(&code_data);
+                input[64..].copy_from_slice(code_parity);
+                let mut tmp_out = [0; LDPCCode::TC128.output_len()];
+                LDPCCode::TC128.decode_ms(
+                    &input,
+                    &mut tmp_out,
+                    &mut working[..LDPCCode::TC128.decode_ms_working_len()],
+                    &mut working_u8[..LDPCCode::TC128.decode_ms_working_u8_len()],
+                    16,
+                );
+                out.try_extend_from_slice(&tmp_out[..(data.len() / 8)])
+                    .ok()?;
+
+                data = &mut data[..0];
+                parity = &mut parity[..0];
+            }
+        }
+    }
+
+    Some(())
+}
+
+fn len_from_soft<T: DecodeFrom>(bits: &[T; 16]) -> u16 {
+    let mut upper = 0;
+    for b in &bits[0..8] {
+        upper <<= 1;
+        upper |= u8::from(b.hard_bit());
+    }
+
+    let mut lower = 0;
+    for b in &bits[8..] {
+        lower <<= 1;
+        lower |= u8::from(b.hard_bit());
+    }
+
+    u16::from_le_bytes([upper, lower])
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::soft_bit::FromHardBit;
+    use bitvec::{order::Msb0, view::BitView};
+
+    #[test]
+    fn len_test() {
+        // from the example in the docs
+        let mut buf = [0; 8191];
+        let mut data = Buffer::new_empty(&mut buf);
+
+        for _ in 0..41 {
+            data.extend(b"Example packet data  wueirpqwerwrywqoeiruy29346129384761");
+        }
+        data.extend(b"Example packet data  wueirpqwerwrywqoeiru346129384761");
+
+        assert_eq!(2349, data.len());
+
+        encode(&mut data).unwrap();
+
+        assert_eq!(4703, data.len());
+    }
+
+    #[test]
+    fn basic_encode_decode_short() {
+        let mut buf = [0; 32];
+        let mut buf2 = [0; 32];
+        let mut data = Buffer::new_empty(&mut buf);
+        data.try_extend_from_slice(b"Hello world!").unwrap();
+        let orig = data.clone_backing(&mut buf2);
+
+        encode(&mut data).unwrap();
+
+        decode(&mut data).unwrap();
+
+        assert_eq!(*orig, *data);
+    }
+
+    #[test]
+    fn basic_encode_decode() {
+        let mut buf = [0; 8191];
+        let mut buf2 = [0; 8191];
+        let mut data = Buffer::new_empty(&mut buf);
+        for _ in 0..50 {
+            data.extend(b"This is a test packet. jsalksjd093809324JASLD:LKD*#$)(*#@)");
+        }
+        let orig = data.clone_backing(&mut buf2);
+
+        encode(&mut data).unwrap();
+        assert_ne!(*orig, *data);
+
+        decode(&mut data).unwrap();
+
+        assert_eq!(*orig, *data);
+    }
+
+    #[test]
+    fn encode_decode_with_bit_flips() {
+        let mut buf = [0; 8191];
+        let mut buf2 = [0; 8191];
+        let mut data = Buffer::new_empty(&mut buf);
+
+        for _ in 0..50 {
+            data.extend(b"jsalksjd093809324JASLD:LKD*#$)(*#@) Another test packet");
+        }
+        let orig = data.clone_backing(&mut buf2);
+
+        encode(&mut data).unwrap();
+        assert_ne!(*orig, *data);
+
+        data[234] ^= 0x55;
+        data[0] ^= 0xAA;
+        data[999] ^= 0x43;
+
+        decode(&mut data).unwrap();
+
+        assert_eq!(*orig, *data);
+    }
+
+    #[test]
+    fn basic_encode_decode_soft() {
+        let mut buf = [0; 8191];
+        let mut buf2 = [0; 8191];
+        let mut data = Buffer::new_empty(&mut buf);
+        for _ in 0..50 {
+            data.extend(b"This is a test packet. jsalksjd093809324JASLD:LKD*#$)(*#@)");
+        }
+        let orig = data.clone_backing(&mut buf2);
+
+        encode(&mut data).unwrap();
+        assert_ne!(*orig, *data);
+
+        let mut soft = [0.0; 8191 * 8];
+        let mut soft = Buffer::new_empty(&mut soft);
+        for b in data.view_bits::<Msb0>() {
+            soft.push(f32::from_hard_bit(*b));
+        }
+
+        let mut out = [0; 8191];
+        let mut out = Buffer::new_empty(&mut out);
+        decode_soft(&mut soft, &mut out).unwrap();
+
+        assert_eq!(*orig, *out);
+    }
+}
--- a/src/lib.rs
+++ b/src/lib.rs
-#![no_std]
+#![cfg_attr(not(test), no_std)]

+pub mod buffer;
 pub mod error;
+pub mod identity;
+pub mod interleaver;
+pub mod ldpc;
 pub mod packet;
+pub mod soft_bit;
 pub mod whisker;
+pub mod whitener;

 mod utf8;
--- a/src/packet.rs
+++ b/src/packet.rs
--- a/src/soft_bit.rs
+++ b/src/soft_bit.rs
+pub use labrador_ldpc::decoder::DecodeFrom;
+
+// Less than zero = 1 bit
+// Greater than zero = 0 bit
+pub trait FromHardBit {
+    fn from_hard_bit(bit: bool) -> Self;
+}
+
+impl<T: DecodeFrom> FromHardBit for T {
+    fn from_hard_bit(bit: bool) -> Self {
+        if bit {
+            -Self::one()
+        } else {
+            Self::one()
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn e2e() {
+        assert!(f32::from_hard_bit(true).hard_bit());
+        assert!(!f32::from_hard_bit(false).hard_bit());
+
+        assert!(f64::from_hard_bit(true).hard_bit());
+        assert!(!f64::from_hard_bit(false).hard_bit());
+
+        assert!(i8::from_hard_bit(true).hard_bit());
+        assert!(!i8::from_hard_bit(false).hard_bit());
+
+        assert!(i16::from_hard_bit(true).hard_bit());
+        assert!(!i16::from_hard_bit(false).hard_bit());
+
+        assert!(i32::from_hard_bit(true).hard_bit());
+        assert!(!i32::from_hard_bit(false).hard_bit());
+    }
+}
--- a/src/whisker/arbitrary.rs
+++ b/src/whisker/arbitrary.rs
 use arrayvec::ArrayVec;

-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Arbitrary(pub ArrayVec<u8, 255>);

 impl Arbitrary {

--- a/src/whisker/destination.rs
+++ b/src/whisker/destination.rs
@@ -2,7 +2,7 @@ use core::str::FromStr;

 use arrayvec::ArrayString;

-#[derive(Debug, PartialEq, Eq)]
+#[derive(Debug, PartialEq, Eq, Clone)]
 pub struct Destination {
    ack: u8,
    callsign: ArrayString<253>,
@@ -36,7 +36,7 @@ impl Destination {
    }

    pub fn ack_num(&self) -> u8 {
-        self.ack
+        self.ack & !(1 << 7)
    }

    pub fn callsign(&self) -> &str {
No results found