region 0.3.0

A library for manipulating memory regions
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
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132

extern crate winapi;

use Protection;
use Region;
use error::*;

fn prot_to_native(protection: Protection) -> winapi::shared::minwindef::DWORD {
  match protection {
    Protection::Read => winapi::um::winnt::PAGE_READONLY,
    Protection::ReadWrite => winapi::um::winnt::PAGE_READWRITE,
    Protection::ReadExecute => winapi::um::winnt::PAGE_EXECUTE_READ,
    Protection::None => winapi::um::winnt::PAGE_NOACCESS,
    _ => winapi::um::winnt::PAGE_EXECUTE_READWRITE,
  }
}

fn prot_from_native(protection: winapi::shared::minwindef::DWORD) -> Protection {
  // Ignore irrelevant flags
  let ignored = winapi::um::winnt::PAGE_GUARD | winapi::um::winnt::PAGE_NOCACHE
    | winapi::um::winnt::PAGE_WRITECOMBINE;

  match protection & !ignored {
    winapi::um::winnt::PAGE_EXECUTE => Protection::Execute,
    winapi::um::winnt::PAGE_EXECUTE_READ => Protection::ReadExecute,
    winapi::um::winnt::PAGE_EXECUTE_READWRITE => Protection::ReadWriteExecute,
    winapi::um::winnt::PAGE_EXECUTE_WRITECOPY => Protection::ReadWriteExecute,
    winapi::um::winnt::PAGE_NOACCESS => Protection::None,
    winapi::um::winnt::PAGE_READONLY => Protection::Read,
    winapi::um::winnt::PAGE_READWRITE => Protection::ReadWrite,
    winapi::um::winnt::PAGE_WRITECOPY => Protection::ReadWrite,
    _ => unreachable!("Protection: {}", protection),
  }
}

pub fn page_size() -> usize {
  use self::winapi::um::sysinfoapi::{GetSystemInfo, SYSTEM_INFO};

  unsafe {
    let mut info: SYSTEM_INFO = ::std::mem::zeroed();
    GetSystemInfo(&mut info);

    info.dwPageSize as usize
  }
}

pub fn get_region(base: *const u8) -> Result<Region> {
  use self::winapi::um::memoryapi::VirtualQuery;
  use self::winapi::um::winnt::MEMORY_BASIC_INFORMATION;

  let mut info: MEMORY_BASIC_INFORMATION = unsafe { ::std::mem::zeroed() };
  let bytes = unsafe {
    VirtualQuery(
      base as winapi::um::winnt::PVOID,
      &mut info,
      ::std::mem::size_of::<MEMORY_BASIC_INFORMATION>() as winapi::shared::basetsd::SIZE_T,
    )
  };

  if bytes > 0 {
    let (protection, guarded) = match info.State {
      winapi::um::winnt::MEM_FREE => Err(Error::Free)?,
      winapi::um::winnt::MEM_RESERVE => (Protection::None, false),
      winapi::um::winnt::MEM_COMMIT => (
        prot_from_native(info.Protect),
        (info.Protect & winapi::um::winnt::PAGE_GUARD) != 0,
      ),
      _ => unreachable!("State: {}", info.State),
    };

    Ok(Region {
      base: info.BaseAddress as *const _,
      shared: (info.Type & winapi::um::winnt::MEM_PRIVATE) == 0,
      size: info.RegionSize as usize,
      protection,
      guarded,
    })
  } else {
    Err(Error::SystemCall(::errno::errno()))
  }
}

pub fn set_protection(base: *const u8, size: usize, protection: Protection) -> Result<()> {
  use self::winapi::um::memoryapi::VirtualProtect;

  let mut prev_flags = 0;
  let result = unsafe {
    VirtualProtect(
      base as winapi::um::winnt::PVOID,
      size as winapi::shared::basetsd::SIZE_T,
      prot_to_native(protection),
      &mut prev_flags,
    )
  };

  if result == winapi::shared::minwindef::FALSE {
    Err(Error::SystemCall(::errno::errno()))
  } else {
    Ok(())
  }
}

pub fn lock(base: *const u8, size: usize) -> Result<()> {
  use self::winapi::um::memoryapi::VirtualLock;
  let result = unsafe {
    VirtualLock(
      base as winapi::um::winnt::PVOID,
      size as winapi::shared::basetsd::SIZE_T,
    )
  };

  if result == winapi::shared::minwindef::FALSE {
    Err(Error::SystemCall(::errno::errno()))
  } else {
    Ok(())
  }
}

pub fn unlock(base: *const u8, size: usize) -> Result<()> {
  use self::winapi::um::memoryapi::VirtualUnlock;
  let result = unsafe {
    VirtualUnlock(
      base as winapi::um::winnt::PVOID,
      size as winapi::shared::basetsd::SIZE_T,
    )
  };

  if result == winapi::shared::minwindef::FALSE {
    Err(Error::SystemCall(::errno::errno()))
  } else {
    Ok(())
  }
}