retour 0.3.1

A cross-platform detour library written in Rust
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

use crate::error::{Error, Result};
use std::ops::Range;

/// Returns an iterator for free after the specified address.
pub fn after(
  origin: *const (),
  range: Option<Range<usize>>,
) -> impl Iterator<Item = Result<*const ()>> {
  FreeRegionIter::new(origin, range, SearchDirection::After)
}

/// Returns an iterator for free before the specified address.
pub fn before(
  origin: *const (),
  range: Option<Range<usize>>,
) -> impl Iterator<Item = Result<*const ()>> {
  FreeRegionIter::new(origin, range, SearchDirection::Before)
}

/// Direction for the region search.
enum SearchDirection {
  Before,
  After,
}

/// An iterator searching for free regions.
struct FreeRegionIter {
  range: Range<usize>,
  search: SearchDirection,
  current: usize,
}

impl FreeRegionIter {
  /// Creates a new iterator for free regions.
  fn new(origin: *const (), range: Option<Range<usize>>, search: SearchDirection) -> Self {
    FreeRegionIter {
      range: range.unwrap_or(0..usize::max_value()),
      current: origin as usize,
      search,
    }
  }
}

impl Iterator for FreeRegionIter {
  type Item = Result<*const ()>;

  /// Returns the closest free region for the current address.
  fn next(&mut self) -> Option<Self::Item> {
    let page_size = region::page::size();

    while self.current > 0 && self.range.contains(&self.current) {
      match region::query(self.current as *const usize) {
        Ok(region) => {
          let range = region.as_range();
          self.current = match self.search {
            SearchDirection::Before => range.start.saturating_sub(page_size),
            SearchDirection::After => range.end,
          }
        },
        Err(error) => {
          // Check whether the region is free, otherwise return the error
          let result = Some(match error {
            region::Error::UnmappedRegion => Ok(self.current as *const _),
            inner => Err(Error::RegionFailure(inner)),
          });

          // Adjust the offset for repeated calls.
          self.current = match self.search {
            SearchDirection::Before => self.current.saturating_sub(page_size),
            SearchDirection::After => self.current + page_size,
          };

          return result;
        },
      }
    }

    None
  }
}