pers 0.1.0

Parser for Windows Portable Executable (PE) files that borrows the file data, a Rust port of PeNet
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

//! Memory mapped files.

use core::ops::{Deref, DerefMut};
use std::fs::{File, OpenOptions};
use std::path::Path;

use memmap2::{Mmap, MmapMut};

use crate::error::{Error, Result};

#[derive(Debug)]
enum Map {
    ReadOnly(Mmap),
    ReadWrite(MmapMut),
}

/// A memory mapped file, the fastest way to parse large files:
/// `PeFile::parse(&MmFile::open_read_only(path)?)`.
///
/// The mapping is only valid as long as no other process truncates the file, the usual
/// contract of memory mapped files.
#[derive(Debug)]
pub struct MmFile {
    map: Map,
}

impl MmFile {
    /// Map the file for reading.
    pub fn open_read_only(path: impl AsRef<Path>) -> Result<Self> {
        let file = File::open(path)?;
        // SAFETY: See the type documentation.
        let map = unsafe { Mmap::map(&file)? };
        Ok(Self {
            map: Map::ReadOnly(map),
        })
    }

    /// Map the file for reading and writing. Writes through [`MmFile::as_mut_slice`] go directly
    /// to the file.
    pub fn open(path: impl AsRef<Path>) -> Result<Self> {
        let file = OpenOptions::new().read(true).write(true).open(path)?;
        // SAFETY: See the type documentation.
        let map = unsafe { MmapMut::map_mut(&file)? };
        Ok(Self {
            map: Map::ReadWrite(map),
        })
    }

    /// The mapped bytes for writing. Fails for read only mappings.
    pub fn as_mut_slice(&mut self) -> Result<&mut [u8]> {
        match &mut self.map {
            Map::ReadOnly(_) => Err(Error::InvalidOperation("the file is mapped read only")),
            Map::ReadWrite(map) => Ok(map.deref_mut()),
        }
    }
}

impl Deref for MmFile {
    type Target = [u8];

    fn deref(&self) -> &[u8] {
        match &self.map {
            Map::ReadOnly(map) => map,
            Map::ReadWrite(map) => map,
        }
    }
}

impl AsRef<[u8]> for MmFile {
    fn as_ref(&self) -> &[u8] {
        self
    }
}