binary-cookies 0.3.1

BinaryCookies decode and encode
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

use std::{error::Error, fmt::Display};

use chrono::offset::LocalResult;
use snafu::{Location, Snafu};
use winnow::error::ContextError;

#[derive(Debug)]
#[derive(Snafu)]
#[snafu(visibility(pub))]
pub enum ParseError {
    #[snafu(display("{render}\n@:{location}"))]
    WinnowCtx {
        render: ContextError,
        #[snafu(implicit)]
        location: Location,
    },
    #[snafu(display("Time broken: {local_result:?}\n@:{location}"))]
    Time {
        local_result: LocalResult<chrono::DateTime<chrono::Utc>>,
        #[snafu(implicit)]
        location: Location,
    },
    #[snafu(display("{source}\n@:{location}"))]
    Bplist {
        source: BplistErr,
        #[snafu(implicit)]
        location: Location,
    },
    #[snafu(display("Read: {source}\n@:{location}",))]
    Read {
        source: std::io::Error,
        #[snafu(implicit)]
        location: Location,
    },
    #[snafu(display("End of binarycookies, can't decode any more data\n@:{location}"))]
    ParsingCompleted {
        #[snafu(implicit)]
        location: Location,
    },
}

impl ParseError {
    pub const fn is_completed(&self) -> bool {
        matches!(self, Self::ParsingCompleted { .. })
    }
}

#[derive(Clone, Copy)]
#[derive(Debug)]
#[derive(Snafu)]
#[snafu(visibility(pub))]
pub enum BplistErr {
    #[snafu(display(
        r#"Not start with b"bplist00"
@:{location}"#
    ))]
    Magic {
        #[snafu(implicit)]
        location: Location,
    },
    #[snafu(display("The object not dict, need update decoder\n@:{location}"))]
    NotDict {
        #[snafu(implicit)]
        location: Location,
    },
    #[snafu(display(
        "The dict key not `NSHTTPCookieAcceptPolicy`, need update decoder\n@:{location}"
    ))]
    BadKey {
        #[snafu(implicit)]
        location: Location,
    },
    #[snafu(display("The int not one byte, need update decoder\n@:{location}"))]
    OneByteInt {
        #[snafu(implicit)]
        location: Location,
    },
}

#[derive(Clone, Copy)]
#[derive(PartialEq, Eq, PartialOrd, Ord)]
pub enum ExpectErr {
    U32(u32),
    U64(u64),
    Magic([u8; 4]),
    EndHeader([u8; 4]),
}

impl std::fmt::Debug for ExpectErr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        f.write_fmt(format_args!("{}", self))
    }
}

impl Error for ExpectErr {}

impl Display for ExpectErr {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            Self::U32(binary) => f.write_fmt(format_args!("got: {:#>06x}", binary)),
            Self::U64(binary) => f.write_fmt(format_args!("got: {:#010x}", binary)),
            Self::Magic(e) => {
                let s: String = e
                    .iter()
                    .map(|&v| v as char)
                    .collect();
                f.write_fmt(format_args!(r#"got: b"{s}""#))
            },
            Self::EndHeader(e) => f.write_fmt(format_args!("got: {e:?}")),
        }
    }
}

pub type Result<T> = std::result::Result<T, ParseError>;