goblin 0.10.4

An impish, cross-platform, ELF, Mach-o, and PE binary parsing and loading crate
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
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157

//! Unified parsing options used across ELF/PE/Mach-O.

/// Binary parsing mode.
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub enum ParseMode {
    /// Fail on malformed data.
    Strict,
    /// Attempt to recover on malformed data.
    Permissive,
}

impl Default for ParseMode {
    fn default() -> Self {
        ParseMode::Strict
    }
}

impl ParseMode {
    /// True if permissive.
    pub(crate) fn is_permissive(&self) -> bool {
        matches!(self, ParseMode::Permissive)
    }
}

/// Common parsing options.
#[non_exhaustive]
#[derive(Debug, Clone, Copy, PartialEq, Eq)]
pub struct ParseOptions {
    /// Selected parsing mode.
    pub parse_mode: ParseMode,
}

impl Default for ParseOptions {
    fn default() -> Self {
        ParseOptions {
            parse_mode: ParseMode::Strict,
        }
    }
}

impl ParseOptions {
    /// Defaults (strict).
    pub fn new() -> Self {
        Default::default()
    }

    /// Permissive defaults.
    pub fn permissive() -> Self {
        ParseOptions {
            parse_mode: ParseMode::Permissive,
        }
    }

    /// Strict defaults.
    pub fn strict() -> Self {
        ParseOptions {
            parse_mode: ParseMode::Strict,
        }
    }

    /// Set parse mode.
    pub fn with_parse_mode(mut self, parse_mode: ParseMode) -> Self {
        self.parse_mode = parse_mode;
        self
    }
}

/// Internal helper trait for permissive fallbacks on `Result<T, E>`.
pub(crate) trait Permissive<T, E> {
    fn or_permissive_and_default(
        self,
        permissive: bool,
        context: &str,
    ) -> core::result::Result<T, E>;

    #[allow(unused)]
    fn or_permissive_and_value(
        self,
        permissive: bool,
        context: &str,
        value: T,
    ) -> core::result::Result<T, E>;

    #[allow(unused)]
    fn or_permissive_and_then<F>(
        self,
        permissive: bool,
        context: &str,
        f: F,
    ) -> core::result::Result<T, E>
    where
        F: FnOnce() -> T;

    // Note: use static context messages to avoid allocations on success path.
}

impl<T: Default, E: core::fmt::Display> Permissive<T, E> for core::result::Result<T, E> {
    #[allow(unused)]
    fn or_permissive_and_default(
        self,
        permissive: bool,
        context: &str,
    ) -> core::result::Result<T, E> {
        self.or_else(|e| {
            if permissive {
                #[cfg(feature = "log")]
                log::warn!("{context}: {e}, continuing with empty/default value");
                Ok(T::default())
            } else {
                Err(e)
            }
        })
    }

    #[allow(unused)]
    fn or_permissive_and_value(
        self,
        permissive: bool,
        context: &str,
        value: T,
    ) -> core::result::Result<T, E> {
        self.or_else(|e| {
            if permissive {
                #[cfg(feature = "log")]
                log::warn!("{context}: {e}, continuing with provided value");
                Ok(value)
            } else {
                Err(e)
            }
        })
    }

    // No lazy-with-ctx variants (keeps this impl alloc-free).

    #[allow(unused)]
    fn or_permissive_and_then<F>(
        self,
        permissive: bool,
        context: &str,
        f: F,
    ) -> core::result::Result<T, E>
    where
        F: FnOnce() -> T,
    {
        self.or_else(|e| {
            if permissive {
                #[cfg(feature = "log")]
                log::warn!("{context}: {e}, continuing with computed value");
                Ok(f())
            } else {
                Err(e)
            }
        })
    }

    // No lazy-with-ctx variants.
}