win_iter 0.1.4

A package that allows you to easily iterate over all running programs on Windows and filter them via architecture. This package only uses bindings for WinAPI functionality.
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

//! # WinAPI Bindings
//!
//! This module contains direct bindings for the Windows API
use std::ffi::c_void;

#[repr(transparent)]
#[allow(non_camel_case_types)]
pub struct CREATE_TOOLHELP_SNAPSHOT_FLAGS(pub u32);

#[repr(transparent)]
#[allow(non_camel_case_types)]
pub struct PROCESS_ACCESS_RIGHTS(pub u32);

impl std::ops::BitOr for PROCESS_ACCESS_RIGHTS {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        PROCESS_ACCESS_RIGHTS(self.0 | rhs.0)
    }
}

impl std::ops::BitOr for CREATE_TOOLHELP_SNAPSHOT_FLAGS {
    type Output = Self;
    fn bitor(self, rhs: Self) -> Self {
        CREATE_TOOLHELP_SNAPSHOT_FLAGS(self.0 | rhs.0)
    }
}

pub const DELETE: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x00010000);
pub const READ_CONTROL: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x00020000);
pub const SYNCHRONIZE: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x00100000);
pub const WRITE_DAC: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x00040000);
pub const WRITE_OWNER: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x00080000);

pub const STANDARD_RIGHTS_REQUIRED: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x000F0000);

pub const PROCESS_TERMINATE: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0001);
pub const PROCESS_CREATE_THREAD: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0002);
pub const PROCESS_VM_OPERATION: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0008);
pub const PROCESS_VM_READ: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0010);
pub const PROCESS_VM_WRITE: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0020);
pub const PROCESS_DUP_HANDLE: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0040);
pub const PROCESS_CREATE_PROCESS: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0080);
pub const PROCESS_SET_QUOTA: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0100);
pub const PROCESS_SET_INFORMATION: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0200);
pub const PROCESS_QUERY_INFORMATION: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0400);
pub const PROCESS_SUSPEND_RESUME: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x0800);
pub const PROCESS_QUERY_LIMITED_INFORMATION: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(0x1000);

pub const PROCESS_ALL_ACCESS: PROCESS_ACCESS_RIGHTS = PROCESS_ACCESS_RIGHTS(STANDARD_RIGHTS_REQUIRED.0 | SYNCHRONIZE.0 | 0xFFFF);

pub const TH32CS_INHERIT: CREATE_TOOLHELP_SNAPSHOT_FLAGS = CREATE_TOOLHELP_SNAPSHOT_FLAGS(0x80000000);
pub const TH32CS_SNAPHEAPLIST: CREATE_TOOLHELP_SNAPSHOT_FLAGS = CREATE_TOOLHELP_SNAPSHOT_FLAGS(0x00000001);
pub const TH32CS_SNAPMODULE: CREATE_TOOLHELP_SNAPSHOT_FLAGS = CREATE_TOOLHELP_SNAPSHOT_FLAGS(0x00000008);
pub const TH32CS_SNAPMODULE32: CREATE_TOOLHELP_SNAPSHOT_FLAGS = CREATE_TOOLHELP_SNAPSHOT_FLAGS(0x00000010);
pub const TH32CS_SNAPPROCESS: CREATE_TOOLHELP_SNAPSHOT_FLAGS = CREATE_TOOLHELP_SNAPSHOT_FLAGS(0x00000002);
pub const TH32CS_SNAPTHREAD: CREATE_TOOLHELP_SNAPSHOT_FLAGS = CREATE_TOOLHELP_SNAPSHOT_FLAGS(0x00000004);
pub const TH32CS_SNAPALL: CREATE_TOOLHELP_SNAPSHOT_FLAGS =
    CREATE_TOOLHELP_SNAPSHOT_FLAGS(TH32CS_SNAPHEAPLIST.0 | TH32CS_SNAPMODULE.0 | TH32CS_SNAPPROCESS.0 | TH32CS_SNAPTHREAD.0);

pub const INVALID_HANDLE_VALUE: HANDLE = HANDLE(-1isize as *mut c_void);

#[repr(transparent)]
#[derive(PartialEq, Copy, Clone)]
pub struct HANDLE(pub *mut c_void);

#[repr(transparent)]
pub struct HRESULT(pub i32);

pub type Result<T> = std::result::Result<T, HRESULT>;

#[repr(C)]
#[allow(non_snake_case)]
pub struct PROCESSENTRY32 {
    pub dwSize: u32,
    pub cntUsage: u32,
    pub th32ProcessID: u32,
    pub th32DefaultHeapID: usize,
    pub th32ModuleID: u32,
    pub cntThreads: u32,
    pub th32ParentProcessID: u32,
    pub pcPriClassBase: i32,
    pub dwFlags: u32,
    pub szExeFile: [i8; 260],
}

#[repr(C)]
#[allow(non_snake_case)]
pub struct MODULEENTRY32 {
    pub dwSize: u32,
    pub th32ModuleID: u32,
    pub th32ProcessID: u32,
    pub GlblcntUsage: u32,
    pub ProccntUsage: u32,
    pub modBaseAddr: *mut u8,
    pub modBaseSize: u32,
    pub hModule: *mut c_void,
    pub szModule: [i8; 256],
    pub szExePath: [i8; 260],
}

impl Default for MODULEENTRY32 {
    fn default() -> Self {
        unsafe { core::mem::zeroed() }
    }
}

impl Default for PROCESSENTRY32 {
    fn default() -> Self {
        Self {
            dwSize: 0,
            cntUsage: 0,
            th32ProcessID: 0,
            th32DefaultHeapID: 0,
            th32ModuleID: 0,
            cntThreads: 0,
            th32ParentProcessID: 0,
            pcPriClassBase: 0,
            dwFlags: 0,
            szExeFile: [0; 260],
        }
    }
}

#[link(name = "kernel32")]
#[allow(dead_code)]
unsafe extern "system" {
    pub fn CreateToolhelp32Snapshot(dwFlags: CREATE_TOOLHELP_SNAPSHOT_FLAGS, th32ProcessId: u32) -> HANDLE;
    pub fn Process32First(hSnapshot: HANDLE, lppe: *mut PROCESSENTRY32) -> i32;
    pub fn Process32Next(hSnapshot: HANDLE, lppe: *mut PROCESSENTRY32) -> i32;
    pub fn Module32First(hSnapshot: HANDLE, llpe: *mut MODULEENTRY32) -> i32;
    pub fn Module32Next(hSnapshot: HANDLE, llpe: *mut MODULEENTRY32) -> i32;
    pub fn GetProcAddress(hModule: *mut c_void, lpProcName: *const i8) -> *mut c_void;
    pub fn LoadLibraryA(lpLibFileName: *const i8) -> *mut c_void;
    pub fn CloseHandle(hObject: HANDLE) -> i32;
    pub fn OpenProcess(dwDesiredAccess: PROCESS_ACCESS_RIGHTS, bInheritHandle: i32, process_id: u32) -> HANDLE;
    pub fn IsWow64Process(hProcess: HANDLE, Wow64Process: &mut i32) -> bool;
}