blkar 7.2.7

Multithreaded archiver offering bit rot protection and sector level recoverability
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
119
120
121
122
123
124
125

use super::crc::*;
use super::BlockType;
use super::Error;
use crate::sbx_specs;
use crate::sbx_specs::{Version, SBX_FILE_UID_LEN, SBX_FIRST_DATA_SEQ_NUM, SBX_SIGNATURE};
use std;

#[derive(Debug, Clone, PartialEq)]
pub struct Header {
    pub version: Version,
    pub crc: u16,
    pub uid: [u8; SBX_FILE_UID_LEN],
    pub seq_num: u32,
}

impl Header {
    pub fn new(version: Version, uid: [u8; SBX_FILE_UID_LEN], seq_num: u32) -> Header {
        Header {
            version,
            crc: 0,
            uid,
            seq_num,
        }
    }

    pub fn to_bytes(&self, buffer: &mut [u8]) {
        if buffer.len() != 16 {
            panic!("Incorrect buffer size");
        }

        {
            // signature
            buffer[0..3].copy_from_slice(SBX_SIGNATURE);
        }
        {
            // version byte
            buffer[3] = sbx_specs::ver_to_usize(self.version) as u8;
        }
        {
            // crc ccitt
            let crc: [u8; 2] = unsafe { std::mem::transmute::<u16, [u8; 2]>(self.crc.to_be()) };
            buffer[4..6].copy_from_slice(&crc);
        }
        {
            // file uid
            buffer[6..12].copy_from_slice(&self.uid);
        }
        {
            // seq num
            let seq_num: [u8; 4] =
                unsafe { std::mem::transmute::<u32, [u8; 4]>(self.seq_num.to_be()) };
            buffer[12..16].copy_from_slice(&seq_num);
        }
    }

    pub fn from_bytes(&mut self, buffer: &[u8]) -> Result<(), Error> {
        if buffer.len() != 16 {
            return Err(Error::IncorrectBufferSize);
        }

        match parsers::header_p(buffer) {
            Ok((_, header)) => {
                *self = header;
                Ok(())
            }
            _ => Err(Error::ParseError),
        }
    }

    pub fn calc_crc(&self) -> u16 {
        let crc = sbx_crc_ccitt(self.version, &self.uid);
        let seq_num: [u8; 4] = unsafe { std::mem::transmute::<u32, [u8; 4]>(self.seq_num.to_be()) };
        crc_ccitt_generic(crc, &seq_num)
    }

    pub fn header_type(&self) -> BlockType {
        if self.seq_num < SBX_FIRST_DATA_SEQ_NUM as u32 {
            BlockType::Meta
        } else {
            BlockType::Data
        }
    }
}

mod parsers {
    use super::Header;
    use super::Version;
    use nom::number::complete::{be_u16, be_u32};

    named!(sig_p, tag!(b"SBx"));

    named!(
        ver_p<Version>,
        alt!(
            complete!(do_parse!(_v: tag!(&[1]) >> (Version::V1)))
                | complete!(do_parse!(_v: tag!(&[2]) >> (Version::V2)))
                | complete!(do_parse!(_v: tag!(&[3]) >> (Version::V3)))
                | complete!(do_parse!(_v: tag!(&[17]) >> (Version::V17)))
                | complete!(do_parse!(_v: tag!(&[18]) >> (Version::V18)))
                | complete!(do_parse!(_v: tag!(&[19]) >> (Version::V19)))
        )
    );

    named!(uid_p, take!(6));

    named!(pub header_p <Header>,
           do_parse!(
               _sig : sig_p >>
                   version : ver_p >>
                   crc     : be_u16 >>
                   uid_raw : uid_p >>
                   seq_num : be_u32 >>
                   ({
                       let mut uid : [u8; 6] = [0; 6];
                       uid.copy_from_slice(uid_raw);
                       Header {
                           version,
                           crc,
                           uid,
                           seq_num
                       }
                   })
           )
    );
}