ashv2 6.0.2

Implementation of the Asynchronous Serial Host (ASH) protocol.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

//! Implementation of byte stuffing and un-stuffing.

use std::io::{Error, ErrorKind, Result};

use crate::protocol::ControlByte;
use crate::protocol::control_byte::ESCAPE;

const RESERVED_BYTES: [u8; 6] = [
    ESCAPE,
    ControlByte::Flag as u8,
    ControlByte::Xon as u8,
    ControlByte::Xoff as u8,
    ControlByte::Substitute as u8,
    ControlByte::Cancel as u8,
];
const COMPLEMENT_BIT: u8 = 1 << 5;

/// Stuff  bytes.
pub trait Stuff {
    /// Stuffs bytes.
    ///
    /// # Errors
    ///
    /// Returns an error if the escape byte could not be inserted, i.e. on potential buffer overflows.
    fn stuff(&mut self) -> Result<()>;
}

/// Un-stuff bytes.
pub trait Unstuff {
    /// Unstuffs bytes.
    fn unstuff(&mut self);
}

impl<const SIZE: usize> Stuff for heapless::Vec<u8, SIZE> {
    fn stuff(&mut self) -> Result<()> {
        let mut index: usize = 0;

        while index < self.len() {
            let byte = &mut self[index];

            if RESERVED_BYTES.contains(byte) {
                *byte ^= COMPLEMENT_BIT;
                self.insert(index, ESCAPE).map_err(|_| {
                    Error::new(ErrorKind::OutOfMemory, "Could not insert escape byte.")
                })?;
                index += 2;
            } else {
                index += 1;
            }
        }

        Ok(())
    }
}

impl Unstuff for Vec<u8> {
    fn unstuff(&mut self) {
        let mut escape_next = false;

        self.retain_mut(|byte| {
            if *byte == ESCAPE {
                escape_next = true;
                return false;
            }

            if escape_next {
                *byte ^= COMPLEMENT_BIT;
                escape_next = false;
            }

            true
        });
    }
}

#[cfg(test)]
mod tests {
    use super::{Stuff, Unstuff};

    #[test]
    fn test_stuffing() {
        let mut unstuffed: heapless::Vec<u8, 12> =
            [0x7E, 0x11, 0x13, 0x18, 0x1A, 0x7D].into_iter().collect();
        let stuffed = [
            0x7D, 0x5E, 0x7D, 0x31, 0x7D, 0x33, 0x7D, 0x38, 0x7D, 0x3A, 0x7D, 0x5D,
        ];
        unstuffed.stuff().expect("could not stuff bytes");
        assert_eq!(unstuffed.as_slice(), stuffed.as_slice());
    }

    #[test]
    fn test_unstuffing() {
        let mut stuffed: Vec<u8> = vec![
            0x7D, 0x5E, 0x7D, 0x31, 0x7D, 0x33, 0x7D, 0x38, 0x7D, 0x3A, 0x7D, 0x5D,
        ]
        .into_iter()
        .collect();
        let unstuffed = [0x7E, 0x11, 0x13, 0x18, 0x1A, 0x7D];
        stuffed.unstuff();
        assert_eq!(stuffed.as_slice(), unstuffed.as_slice());
    }

    #[test]
    fn test_unstuffing_unchanged() {
        let payload: Vec<u8> = vec![
            0xd7, 0x90, 0xd7, 0xa0, 0xd7, 0x99, 0x20, 0xd7, 0x96, 0xd7, 0x95, 0xd7, 0x9b, 0xd7,
            0xa8, 0x20, 0xd7, 0x91, 0xd7, 0x9c, 0xd7, 0x99, 0xd7, 0x9c, 0xd7, 0x95, 0xd7, 0xaa,
            0x20, 0xd7, 0xa9, 0xd7, 0x9c, 0x20, 0xd7, 0x99, 0xd7, 0xa8, 0xd7, 0x97, 0x20, 0xd7,
            0x9e, 0xd7, 0x9c, 0xd7, 0x90, 0x20, 0xd7, 0x94, 0xd7, 0x99, 0xd7, 0x99, 0xd7, 0xaa,
            0x20, 0xd7, 0x91, 0xd7, 0x90, 0xd7, 0x94, 0x20, 0xd7, 0x90, 0xd7, 0x9c, 0xd7, 0x99,
        ]
        .into_iter()
        .collect();
        let mut clone = payload.clone();
        clone.unstuff();
        assert_eq!(clone.as_slice(), payload.as_slice());
    }
}