elrond 1.0.0

Standard conformant elf 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
109
110
111
112
113
114
115
116


use super::super::nom::{IResult, ErrorKind, le_u8};

use super::super::{Fault, nom_bullshit};

/*
 * LE/BE doesn't matter when reading bytes
 * individual bytes
 */
use super::abi::{ElfAbi, Abi, parse_elf_abi};
use super::endian::{ElfEndian, Endian, parse_elf_endian};
use super::class::{ElfClass, Class, parse_elf_class};
use super::traits::{ElfMagicNumber};

/// Data extracted from magic numbers
#[derive(Copy,Clone,Debug,Hash)]
pub struct ElfMagicNumbers {
    class: ElfClass,
    endian: ElfEndian,
    abi: ElfAbi,
    abi_version: u8,
}
impl Abi for ElfMagicNumbers {
    #[inline(always)]
    fn get_abi(&self) -> ElfAbi {
        self.abi.clone()
    }
}
impl Endian for ElfMagicNumbers {
    #[inline(always)]
    fn get_endian(&self) -> ElfEndian {
        self.endian.clone()
    }
}
impl Class for ElfMagicNumbers {
    #[inline(always)]
    fn get_class(&self) -> ElfClass {
        self.class.clone()
    }
}
impl ElfMagicNumber for ElfMagicNumbers {
    #[inline(always)]
    fn get_abi_version(&self) -> u8 {
        self.abi_version.clone()
    }
}

named!(check_magic<&[u8],&[u8],u32>,
    add_return_error!(ErrorKind::Custom(1u32),
    tag!(b"\x7F\x45\x4C\x46")
));

named!(pub parse_elf_magic<&[u8],ElfMagicNumbers,u32>, do_parse!(
    check_magic >>
    class: parse_elf_class >>
    endian: parse_elf_endian >> 
    take!(1) >>
    abi: parse_elf_abi >>
    abi_version: le_u8 >>
    take!(7) >>
    ( ElfMagicNumbers{
        class, endian, abi, abi_version
    })
));

#[test]
fn test_check_magic() {

    //passing test
    let dut0 = b"\x7F\x45\x4C\x46\xDE\xAD\xBE\xEF";
    let (rem,var) = match check_magic(dut0) {
        IResult::Done(x,y) => (x,y),
        IResult::Incomplete(n) => panic!("check magic failed {:?}",n),
        IResult::Error(e) => panic!("check magic failed {:?}",e)
    };
    assert_eq!(rem.len(), 4);
    assert_eq!(rem, b"\xDE\xAD\xBE\xEF");
    assert_eq!(var.len(), 4);
    assert_eq!(var, b"\x7F\x45\x4C\x46");
    
    //failing test
    let dut1 = b"\x00\x45\x4C\x46\xDE\xAD\xBE\xEF";
    match check_magic(dut1) {
        IResult::Done(_,_) => panic!("check magic should fail"),
        IResult::Incomplete(n) => panic!("check magic wrong error {:?}",n),
        IResult::Error(e) => {
            match nom_bullshit(e) {
                ErrorKind::Custom(1u32) => { }
                ErrorKind::Custom(x) => panic!("check magic wrong error code {:?}", x),
                e => panic!("check magic wrong error code {:?}", e)
            }
        }
    };
}

#[test]
fn test_parse_elf_magic() {

    //passing test
    let dut0: &[u8] = b"\x7F\x45\x4C\x46\x02\x01\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00";
    let (rem, magic) = match parse_elf_magic(dut0) {
        IResult::Done(x,m) => (x,m),
        IResult::Incomplete(n) => panic!("check_version failed {:?}",n),
        IResult::Error(e) => panic!("check_version failed {:?}",e)
    };
    //check remainer
    assert_eq!(rem.len(), 1);
    assert_eq!(rem[0],0);

    //check values
    assert_eq!(magic.get_abi(), ElfAbi::SystemV);
    assert_eq!(magic.get_endian(), ElfEndian::Little);
    assert_eq!(magic.get_class(), ElfClass::Bits64);
    assert_eq!(magic.get_abi_version(), 0);
}