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]

[package]

name = "ham-cats"

name = "ham-cats"

version = "0.1.0"

version = "0.2.2"

edition = "2021"

edition = "2021"

license = "MIT"

license = "MIT"

description = "Reference implementations for CATS, the ham radio protocol"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

repository = "https://gitlab.scd31.com/cats/ham_cats"

homepage = "https://cats.radio"

categories = ["embedded", "encoding", "no-std", "no-std::no-alloc"]

[dependencies]

[dependencies]

arrayvec = { version = "0.7.4", default-features = false }

arrayvec = { version = "0.7.4", default-features = false }

crc = "3.0.1"

crc = "3.0.1"

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

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

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

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

labrador-ldpc = "1.1"

labrador-ldpc = "1.2.1"

paste = "1.0.14"

paste = "1.0.14"

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

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]]

[[package]]

name = "ham-cats"

name = "ham-cats"

version = "0.1.0"

version = "0.2.0"

dependencies = [

dependencies = [

 "arrayvec",

 "arrayvec",

 "bitvec",

 "bitvec",

[[package]]

[[package]]

name = "labrador-ldpc"

name = "labrador-ldpc"

version = "1.1.0"

version = "1.1.1"

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

checksum = "2ff4a0568f6322b64e06b6a6a0810e2f64670aa325f6e9dca24084e99917f459"

[[package]]

[[package]]

name = "libc"

name = "libc"

test = false

test = false

doc = false

doc = false

[[bin]]

[[bin]]

name = "fuzz_target_3"

name = "fuzz_target_3"

path = "fuzz_targets/fuzz_target_3.rs"

path = "fuzz_targets/fuzz_target_3.rs"

test = false

test = false

doc = false

doc = false

[[bin]]

name = "fuzz_target_4"

path = "fuzz_targets/fuzz_target_4.rs"

test = false

doc = false

use ham_cats::packet::Packet;

use ham_cats::packet::Packet;

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

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]

#![no_main]

use libfuzzer_sys::fuzz_target;

use libfuzzer_sys::fuzz_target;

use ham_cats::packet::Packet;

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

use std::convert::TryInto;

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

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

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

    let mut buf = [0; 1024];

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

    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]

#![no_main]

use libfuzzer_sys::fuzz_target;

use libfuzzer_sys::fuzz_target;

use ham_cats::packet::Packet;

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

use std::convert::TryInto;

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

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

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

    let mut buf = [0; 1024];

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

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

});

pub struct BufferOverflow;

pub struct BufferOverflow;

#[derive(Debug)]

#[derive(Debug)]

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

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

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

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

    i: usize,

    i: usize,

}

}

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

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

    /// Constructs a new `Buffer`.

    /// Constructs a new `Buffer`.

    /// `data` is the backing array.

    /// `data` is the backing array.

    /// `i` is the number of elements in `data` that contain data (and should thus be exposed by `Buffer`)

    /// `i` is the number of elements in `data` that contain data (and should thus be exposed by `Buffer`)

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

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

        assert!(i <= data.len());

        assert!(i <= data.len());

        Self { data, i }

        Self { data, i }

    }

    }

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

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

        let i = data.len();

        let i = data.len();

        Self::new(data, i)

        Self::new(data, i)

    }

    }

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

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

        Self::new(data, 0)

        Self::new(data, 0)

    }

    }

        N - self.i

        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 {

        if self.i == N {

            return Err(BufferOverflow);

            return Err(BufferOverflow);

        }

        }

        Ok(())

        Ok(())

    }

    }

    pub fn push(&mut self, v: u8) {

    pub fn push(&mut self, v: T) {

        self.try_push(v).unwrap();

        self.try_push(v).unwrap();

    }

    }

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

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

        if self.remaining_capacity() < other.len() {

        if self.remaining_capacity() < other.len() {

            return Err(BufferOverflow);

            return Err(BufferOverflow);

        }

        }

        Ok(())

        Ok(())

    }

    }

    pub fn extend(&mut self, other: &[u8]) {

    pub fn extend(&mut self, other: &[T]) {

        self.try_extend_from_slice(other).unwrap();

        self.try_extend_from_slice(other).unwrap();

    }

    }

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

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

        if self.i == 0 {

        if self.i == 0 {

            return None;

            return None;

        }

        }

        self.i -= delta;

        self.i -= delta;

    }

    }

    pub fn clone_backing<'b>(&self, buf: &'b mut [u8; N]) -> Buffer<'b, N> {

    pub fn clone_backing<'b>(&self, buf: &'b mut [T; N]) -> Buffer<'b, N, T> {

        let mut out = Buffer::new_empty(buf);

        let mut out = Buffer::new_empty(buf);

        out.extend(self);

        out.extend(self);

    }

    }

}

}

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

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

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

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

        Self { data, i: 0 }

        Self { data, i: 0 }

    }

    }

}

}

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

impl<const N: usize, T> Deref for Buffer<'_, N, T> {

    type Target = [u8];

    type Target = [T];

    fn deref(&self) -> &Self::Target {

    fn deref(&self) -> &Self::Target {

        &self.data[..self.i]

        &self.data[..self.i]

    }

    }

}

}

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

impl<const N: usize, T> DerefMut for Buffer<'_, N, T> {

    fn deref_mut(&mut self) -> &mut [u8] {

    fn deref_mut(&mut self) -> &mut [T] {

        &mut self.data[..self.i]

        &mut self.data[..self.i]

    }

    }

}

}

    #[snafu(display("Given buffer too small for comment data"))]

    #[snafu(display("Given buffer too small for comment data"))]

    BufferOverflow,

    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 bitvec::prelude::*;

use bitvec::prelude::*;

use labrador_ldpc::decoder::DecodeFrom;

use crate::{

use crate::{

    buffer::{Buffer, BufferOverflow},

    buffer::{Buffer, BufferOverflow},

    Ok(())

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

#[cfg(test)]

mod tests {

mod tests {

    use super::*;

    use super::*;

    use crate::soft_bit::FromHardBit;

    #[test]

    #[test]

    fn interleaver_works() {

    fn interleaver_works() {

        assert_eq!(*orig, *uninterleaved);

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

            }

        }

    }

}

}

use labrador_ldpc::LDPCCode;

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

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

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