Compare revisions

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

[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 }

crc = "3.0.1"

encoding_rs = { version = "0.8.33", default-features = false }

half = { version = "2.3.1", default-features = false }

labrador-ldpc = "1.1"

labrador-ldpc = "1.2.1"

paste = "1.0.14"

snafu = { version = "0.7.5", default-features = false }

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.

[[package]]

name = "ham-cats"

version = "0.1.0"

version = "0.2.0"

dependencies = [

 "arrayvec",

 "bitvec",

[[package]]

name = "labrador-ldpc"

version = "1.1.0"

source = "registry+https://github.com/rust-lang/crates.io-index"

checksum = "2ff4a0568f6322b64e06b6a6a0810e2f64670aa325f6e9dca24084e99917f459"

version = "1.1.1"

[[package]]

name = "libc"

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

use ham_cats::packet::Packet;

fuzz_target!(|data: &[u8]| {

    let _ = Packet::<1024>::fully_decode(data);

    let mut buf = [0; 1024];

    let _ = Packet::<1024>::fully_decode(data, &mut buf);

});

#![no_main]

use libfuzzer_sys::fuzz_target;

use ham_cats::packet::Packet;

use std::convert::TryInto;

use ham_cats::{buffer::Buffer, packet::Packet};

fuzz_target!(|data: &[u8]| {

    if let Ok(data) = data.try_into() {

        let _ = Packet::<1024>::semi_decode(data);

    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);

    }

});

#![no_main]

use libfuzzer_sys::fuzz_target;

use ham_cats::packet::Packet;

use std::convert::TryInto;

use ham_cats::{buffer::Buffer, packet::Packet};

fuzz_target!(|data: &[u8]| {

    if let Ok(data) = data.try_into() {

        let _ = Packet::<1024>::decode(data);

    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);

    }

});

#![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);

});

use core::{borrow::Borrow, ops::Deref};

use core::ops::{Deref, DerefMut};

pub(crate) struct BufferOverflow;

#[derive(Debug)]

pub struct BufferOverflow;

pub(crate) struct Buffer<'a, const N: usize> {

    data: &'a mut [u8; N],

#[derive(Debug)]

pub struct Buffer<'a, const N: usize, T = u8> {

    data: &'a mut [T; N],

    i: usize,

}

impl<'a, const N: usize> Buffer<'a, N> {

    pub fn new(data: &'a mut [u8; N], i: usize) -> Self {

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 as_slice(&self) -> &'a [u8] {

            &self.data[..self.i]

    pub fn new_full(data: &'a mut [T; N]) -> Self {

        let i = data.len();

        Self::new(data, i)

    }

        pub fn as_slice_mut(&mut self) -> &'a [u8] {

            &mut self.data[..self.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: u8) -> Result<(), BufferOverflow> {

    pub fn try_push(&mut self, v: T) -> Result<(), BufferOverflow> {

        if self.i == N {

            return Err(BufferOverflow);

        }

        Ok(())

    }

    pub fn try_extend_from_slice(&mut self, other: &[u8]) -> Result<(), BufferOverflow> {

    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);

        }

        Ok(())

    }

    pub fn pop(&mut self) -> Option<u8> {

    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;

        }

        Some(self.data[self.i])

    }

    pub fn truncate(&mut self, new_len: usize) {

        assert!(self.i >= new_len);

        self.i = new_len;

    }

impl<'a, const N: usize> From<&'a mut [u8; N]> for Buffer<'a, N> {

    fn from(data: &'a mut [u8; N]) -> Self {

    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<'a, const N: usize> Deref for Buffer<'a, N> {

    type Target = [u8];

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]

    }

}

    #[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,

}

#[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

    }

}

use arrayvec::{ArrayVec, CapacityError};

use bitvec::prelude::*;

use labrador_ldpc::decoder::DecodeFrom;

use crate::error::EncodeError;

use crate::{

    buffer::{Buffer, BufferOverflow},

    error::EncodeError,

};

pub(crate) fn interleave<const N: usize>(

    data: &[u8],

    out: &mut ArrayVec<u8, N>,

    out: &mut Buffer<N>,

) -> Result<(), EncodeError> {

    let bv = data.view_bits::<Msb0>();

pub(crate) fn uninterleave<const N: usize>(

    data: &[u8],

) -> Result<ArrayVec<u8, N>, CapacityError<u8>> {

    out: &mut Buffer<N>,

) -> Result<(), BufferOverflow> {

    let bv = data.view_bits::<Msb0>();

    let mut out: ArrayVec<u8, N> = ArrayVec::new();

    for _ in 0..data.len() {

        out.try_push(0)?;

    }

        }

    }

    Ok(out)

    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 orig =

            ArrayVec::try_from([0x84, 0x73, 0x12, 0xA3, 0xFF, 0x00, 0xC2, 0x1B, 0x77]).unwrap();

        let mut interleaved: ArrayVec<u8, 10> = ArrayVec::new();

        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 uninterleaved = uninterleave(&interleaved[1..]).unwrap();

        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, uninterleaved);

        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);

            }

        }

    }

}

use arrayvec::ArrayVec;

use labrador_ldpc::LDPCCode;

use labrador_ldpc::{decoder::DecodeFrom, LDPCCode};

use crate::{buffer::Buffer, error::EncodeError};

    };

}

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;

    Ok(())

}

pub(crate) fn decode<const N: usize>(data_av: &mut ArrayVec<u8, N>) -> Option<()> {

pub(crate) fn decode<const N: usize>(data_av: &mut Buffer<N>) -> Option<()> {

    if data_av.len() < 2 {

        return None;

    }

    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,