processes 0.4.0

A utility library for accessing processes and modules on windows.
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
133
134
135
136
137
138

use std::io;

use thiserror::Error;
use winapi::shared::winerror::ERROR_PARTIAL_COPY;

#[derive(Debug, Error)]
/// Error enum representing an error of an operation on a process.
pub enum ProcessError {
    /// Variant representing an inaccessible target process.
    /// This can occur if it crashed or was terminated.
    #[error("inaccessible target process")]
    ProcessInaccessible,
    /// Variant representing an windows api error.
    #[error("io error: {}", _0)]
    Io(io::Error),
    // #[error("native error: {:#04x}", _0.code())]
    // Native(winresult::NtStatus),
}

impl From<io::Error> for ProcessError {
    fn from(err: io::Error) -> Self {
        if err.raw_os_error() == Some(ERROR_PARTIAL_COPY as _)
            || err.kind() == io::ErrorKind::PermissionDenied
        {
            Self::ProcessInaccessible
        } else {
            Self::Io(err)
        }
    }
}

#[derive(Debug, Error)]
/// Error enum representing an error of an operation on a process.
pub enum ProcessOrPathError {
    /// Variant representing a process error.
    #[error("process error: {}", _0)]
    Process(#[from] ProcessError),
    /// Variant representing an illegal interior nul value in the module path.
    #[error("path contains illegal interior nul")]
    IllegalPath,
}

impl From<io::Error> for ProcessOrPathError {
    fn from(err: io::Error) -> Self {
        Self::Process(err.into())
    }
}

impl From<widestring::error::ContainsNul<u16>> for ProcessOrPathError {
    fn from(_err: widestring::error::ContainsNul<u16>) -> Self {
        Self::IllegalPath
    }
}

impl From<std::ffi::FromBytesWithNulError> for ProcessOrPathError {
    fn from(_err: std::ffi::FromBytesWithNulError) -> Self {
        Self::IllegalPath
    }
}

impl From<std::ffi::NulError> for ProcessOrPathError {
    fn from(_err: std::ffi::NulError) -> Self {
        Self::IllegalPath
    }
}

#[derive(Debug, Error)]
/// Error enum representing either a windows api error or a nul error from an invalid interior nul.
pub enum IoOrNulError {
    /// Variant representing an illegal interior nul value.
    #[error("interior nul found")]
    Nul(#[from] widestring::error::ContainsNul<u16>),
    /// Variant representing an windows api error.
    #[error("io error: {}", _0)]
    Io(#[from] io::Error),
}

/// Error enum for errors during a call to [`ProcessModule::get_local_procedure_address`].
///
/// [`ProcessModule::get_local_procedure_address`]: crate::ProcessModule::get_local_procedure_address
#[derive(Debug, Error)]
pub enum GetLocalProcedureAddressError {
    /// Variant representing an inaccessible target process.
    /// This can occur if it crashed or was terminated.
    #[error("inaccessible target process")]
    ProcessInaccessible,
    /// Variant representing an illegal interior nul value in the module path.
    #[error("path contains illegal interior nul")]
    IllegalPath,
    /// Variant representing an windows api error.
    #[error("io error: {}", _0)]
    Io(io::Error),
    /// Variant representing an unsupported target process.
    #[error("unsupported remote target process")]
    UnsupportedRemoteTarget,
}

impl From<io::Error> for GetLocalProcedureAddressError {
    fn from(err: io::Error) -> Self {
        ProcessError::from(err).into()
    }
}

impl From<ProcessError> for GetLocalProcedureAddressError {
    fn from(err: ProcessError) -> Self {
        match err {
            ProcessError::ProcessInaccessible => Self::ProcessInaccessible,
            ProcessError::Io(e) => Self::Io(e),
        }
    }
}

impl From<ProcessOrPathError> for GetLocalProcedureAddressError {
    fn from(err: ProcessOrPathError) -> Self {
        match err {
            ProcessOrPathError::Process(e) => e.into(),
            ProcessOrPathError::IllegalPath => Self::IllegalPath,
        }
    }
}

impl From<widestring::error::ContainsNul<u16>> for GetLocalProcedureAddressError {
    fn from(_err: widestring::error::ContainsNul<u16>) -> Self {
        Self::IllegalPath
    }
}

impl From<std::ffi::FromBytesWithNulError> for GetLocalProcedureAddressError {
    fn from(_err: std::ffi::FromBytesWithNulError) -> Self {
        Self::IllegalPath
    }
}

impl From<std::ffi::NulError> for GetLocalProcedureAddressError {
    fn from(_err: std::ffi::NulError) -> Self {
        Self::IllegalPath
    }
}