schnauzer 0.3.5

Library for parsing Mach-O files
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

use std::fmt::{Debug, Display};

#[derive(PartialEq)]
pub enum Magic {
    Fat,
    FatReverse,
    Bin32,
    Bin32Reverse,
    Bin64,
    Bin64Reverse,
}

impl Magic {
    pub fn raw_value(&self) -> u32 {
        match self {
            Magic::Fat => 0xcafebabe,
            Magic::FatReverse => 0xbebafeca,
            Magic::Bin32 => 0xfeedface,
            Magic::Bin32Reverse => 0xcefaedfe,
            Magic::Bin64 => 0xfeedfacf,
            Magic::Bin64Reverse => 0xcffaedfe,
        }
    }

    pub fn is_fat(&self) -> bool {
        match self {
            Self::Fat | Self::FatReverse => true,
            _ => false,
        }
    }

    pub fn is_reverse(&self) -> bool {
        match self {
            Magic::FatReverse => true,
            Magic::Bin32Reverse => true,
            Magic::Bin64Reverse => true,
            _ => false,
        }
    }

    pub fn is_64(&self) -> bool {
        match self {
            Self::Bin64 | Self::Bin64Reverse => true,
            _ => false,
        }
    }
}

impl TryInto<Magic> for u32 {
    type Error = crate::result::Error;

    fn try_into(self) -> std::result::Result<Magic, Self::Error> {
        match self {
            0xcafebabe => Ok(Magic::Fat),
            0xbebafeca => Ok(Magic::FatReverse),
            0xfeedface => Ok(Magic::Bin32),
            0xcefaedfe => Ok(Magic::Bin32Reverse),
            0xfeedfacf => Ok(Magic::Bin64),
            0xcffaedfe => Ok(Magic::Bin64Reverse),
            _ => Err(Self::Error::BadMagic(self)),
        }
    }
}

impl Magic {
    pub(super) fn endian(&self) -> scroll::Endian {
        if self.is_fat() || !self.is_reverse() {
            scroll::BE
        } else {
            scroll::LE
        }
    }
}

impl Clone for Magic {
    fn clone(&self) -> Self {
        match self {
            Self::Fat => Self::Fat,
            Self::FatReverse => Self::FatReverse,
            Self::Bin32 => Self::Bin32,
            Self::Bin32Reverse => Self::Bin32Reverse,
            Self::Bin64 => Self::Bin64,
            Self::Bin64Reverse => Self::Bin64Reverse,
        }
    }
}

impl Copy for Magic {}

impl Display for Magic {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:x}", self.raw_value())
    }
}

impl Debug for Magic {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "{:#x}", self.raw_value())
    }
}