crabstep 0.3.2

Cross-platform, zero-dependency Apple/NeXTSTEP typedstream deserializer
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

//! Header validation for `TypedStream` format

use crate::{
    deserializer::{
        consumed::Consumed,
        number::{read_signed_int, read_unsigned_int},
        string::read_string,
    },
    error::{Result, TypedStreamError},
};

/// Validate the `typedstream` header for macOS/iOS format.
///
/// Reads version, signature, and system version, returning a [`Consumed<bool>`]
/// indicating validity and bytes consumed.
///
/// # Errors
///
/// Returns [`TypedStreamError::InvalidHeader`] if the header does not match expected values.
///
/// # Examples
/// ```no_run
/// use crabstep::deserializer::header::validate_header;
///
/// let data: &[u8] = &[
///     0x04, 0x0b, b's', b't', b'r', b'e', b'a', b'm', b't', b'y', b'p', b'e', b'd',
///     0x81, 0xe8, 0x03,
/// ];
///
/// let result = validate_header(data).unwrap();
/// assert!(result.value);
/// assert_eq!(result.bytes_consumed, 16);
/// ```
pub fn validate_header(data: &[u8]) -> Result<Consumed<bool>> {
    // Encoding type
    let typedstream_version = read_unsigned_int(data)?;
    // Encoding signature
    let signature = read_string(&data[typedstream_version.bytes_consumed..])?;
    // System version
    let system_version =
        read_signed_int(&data[typedstream_version.bytes_consumed + signature.bytes_consumed..])?;

    if typedstream_version.value != 4
        || signature.value != "streamtyped"
        || system_version.value != 1000
    {
        return Err(TypedStreamError::InvalidHeader);
    }

    Ok(Consumed::new(
        true,
        typedstream_version.bytes_consumed
            + signature.bytes_consumed
            + system_version.bytes_consumed,
    ))
}

#[cfg(test)]
mod header_tests {
    extern crate std;
    use alloc::vec;
    use std::{env::current_dir, fs::File, io::Read, println};

    use crate::deserializer::{constants::I_16, header::validate_header};

    #[test]
    fn can_validate_header() {
        let data = [
            0x04, // TypedStream version (4)
            0x0b, // Length of the signature
            b's', b't', b'r', b'e', b'a', b'm', b't', b'y', b'p', b'e', b'd', // Signature
            I_16, 0xe8, 0x03, // System version (1000 in little-endian)
        ];
        let result = validate_header(&data).unwrap();

        assert!(result.value);
        assert_eq!(result.bytes_consumed, 16);
    }

    #[test]
    fn can_validate_real_header() {
        let typedstream_path = current_dir()
            .unwrap()
            .as_path()
            .join("src/test_data/AttributedBodyTextOnly");
        println!("Parsing file: {typedstream_path:?}");
        let mut file = File::open(typedstream_path).unwrap();
        let mut bytes = vec![];
        file.read_to_end(&mut bytes).unwrap();

        // Skip the header for now
        let validated = validate_header(&bytes).unwrap();

        assert!(validated.value);
        assert_eq!(validated.bytes_consumed, 16);
    }

    #[test]
    fn fails_on_invalid_header() {
        let data = [0x01]; // Invalid TypedStream version
        assert!(validate_header(&data).is_err());
    }
}