binfmt 0.1.0

A library for reading and writing binaries
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

use crate::fmt::{BinaryFile, Binfmt, CallbackError, FileType, Section, SectionType};

pub struct Binary;

pub fn create_format() -> Binary {
    Binary
}

impl Binfmt for Binary {
    fn relnum_to_howto(&self, _relnum: u32) -> Option<&dyn crate::howto::HowTo> {
        None
    }

    fn code_to_howto(&self, _code: crate::howto::RelocCode) -> Option<&dyn crate::howto::HowTo> {
        None
    }

    fn name(&self) -> &'static str {
        "binary"
    }

    fn create_file(&self, ty: FileType) -> crate::fmt::BinaryFile {
        BinaryFile::create(self, Box::new(()), ty)
    }

    fn read_file(
        &self,
        file: &mut (dyn std::io::Read + '_),
    ) -> std::io::Result<Option<crate::fmt::BinaryFile>> {
        let mut vec = Vec::new();
        file.read_to_end(&mut vec)?;
        let mut file = BinaryFile::create(self, Box::new(()), FileType::Exec);
        let _ = file.add_section(Section {
            align: 1,
            content: vec,
            name: ".data".to_string(),
            ty: SectionType::ProgBits,
            relocs: Vec::new(),
            __private: (),
        });

        Ok(Some(file))
    }

    fn write_file(
        &self,
        file: &mut (dyn std::io::Write + '_),
        bfile: &crate::fmt::BinaryFile,
    ) -> std::io::Result<()> {
        for s in bfile.sections() {
            file.write_all(&s.content)?;
        }
        Ok(())
    }

    fn has_sections(&self) -> bool {
        true
    }

    fn create_section(
        &self,
        _section: &mut crate::fmt::Section,
    ) -> Result<(), crate::fmt::CallbackError> {
        Ok(())
    }

    fn create_symbol(
        &self,
        _sym: &mut crate::sym::Symbol,
    ) -> Result<(), crate::fmt::CallbackError> {
        Err(CallbackError::NotAccepted)
    }

    fn create_reloc(
        &self,
        _reloc: &mut crate::howto::Reloc,
    ) -> Result<(), crate::fmt::CallbackError> {
        Err(CallbackError::NotAccepted)
    }

    fn before_relocate(&self, _reloc: &mut crate::howto::Reloc, _symbol: &crate::sym::Symbol) {}
}