rustep 0.1.2

Rust Executable file Parser
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

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

use failure::{
    Context,
    Fail,
    Backtrace,
};

#[derive(Debug)]
pub struct RustepError {
    inner: Context<RustepErrorKind>
}

#[derive(Copy, Clone, Eq, PartialEq, Debug, Fail)]
pub enum RustepErrorKind {
    #[fail(display = "Unsupported ELF class value {}", _0)]
    UnsupportedElfClass(u8),
    #[fail(display = "Parsing error")]
    Parse,
    #[fail(display = "Not enough byte, {} bytes needed", _0)]
    Incomplete(usize),
    #[fail(display = "Not enough byte, unknown bytes needed")]
    IncompleteUnknown,
    #[fail(display = "Segment type {} not resolved", _0)]
    SegmentType(u64),
    #[fail(display = "Section type {} not resolved", _0)]
    SectionType(u64),
    #[fail(display = "Segment flag {} invalid", _0)]
    SegmentFlag(u64),
    #[fail(display = "Section flag {} invalid", _0)]
    SectionFlag(u64),
    #[fail(display = "Unknown elf type {}", _0)]
    ElfType(u64),
    #[fail(display = "Unknown elf machine {}", _0)]
    ElfMachine(u64),
    #[fail(display = "Not an Elf file")]
    NotElf,
}

impl Fail for RustepError {
    fn cause(&self) -> Option<&Fail> {
        self.inner.cause()
    }

    fn backtrace(&self) -> Option<&Backtrace> {
        self.inner.backtrace()
    }
}

impl Display for RustepError {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        Display::fmt(&self.inner, f)
    }
}

impl RustepError {
    pub fn kind(&self) -> RustepErrorKind {
        *self.inner.get_context()
    }
}

impl From<RustepErrorKind> for RustepError {
    fn from(kind: RustepErrorKind) -> RustepError {
        RustepError { inner: Context::new(kind) }
    }
}

impl From<Context<RustepErrorKind>> for RustepError {
    fn from(inner: Context<RustepErrorKind>) -> RustepError {
        RustepError { inner: inner }
    }
}

/// Crate `Failure` has not supported `nom`, or `nom` not supported `Failure`.
/// To avoid to do error handling manually, this macro is used to emulate the try method to be
/// better to use along with `Failure`.
///
/// # Examples
/// ```
/// use nom::*;
/// 
/// let res = tag!(b"abc", "bcd"); // Here will be an IResult returned from nom.
/// let res_err = nom_try!(res); // This is almost like `res?`, it will return early
/// let res = tag!(b"abc", "abc"); // This will be accepted
/// let res_noerr = nom_try!(res); // The Done part of nom will be extracted
/// ```
macro_rules! nom_try {

    ($arg:expr) => {
        match $arg {
            Done(_i, res) => {
                res
            },
            Error(e) => {
                Err(format_err!("Parse Error {}", e.to_string()).context(RustepErrorKind::Parse))?
            },
            Incomplete(needed) => {
                match needed {
                    Size(s) => Err(RustepErrorKind::Incomplete(s))?,
                    Unknown => Err(RustepErrorKind::IncompleteUnknown)?,
                }
            }
        }
    }
}