vrc-log 0.15.4

VRChat Local Avatar ID Logger
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
139
140
141
142
143
144
145
146

use std::{
    io::ErrorKind,
    path::PathBuf,
    process::{Command, ExitStatus, Stdio},
    sync::LazyLock,
};

use tokio::task::JoinHandle;
use windows::Win32::{
    Foundation::{CloseHandle, HANDLE},
    Security::{GetTokenInformation, TokenElevation, TOKEN_ELEVATION, TOKEN_QUERY},
    System::Threading::{GetCurrentProcess, OpenProcessToken},
};

use crate::vrchat::VRCHAT_LOW_PATH;

pub const PROCMON_BACKING_NAME: &str = "VRC-LOG.PML";
pub const PROCMON_CONFIG_NAME: &str = "VRC-LOG.PMC";
pub const PROCMON_CONFIG_BYTES: &[u8] = include_bytes!("../VRC-LOG.PMC");

pub static TEMP_DIR_PATH: LazyLock<PathBuf> = LazyLock::new(std::env::temp_dir);

/// # Checks if the process has elevated privileges.
/// # Errors
/// Will return `Err` if `OpenProcessToken`, `GetTokenInformation`, or `CloseHandle` fail.
pub fn is_elevated() -> windows::core::Result<bool> {
    unsafe {
        let mut h_token = HANDLE(0 as _);
        if let Err(error) = OpenProcessToken(GetCurrentProcess(), TOKEN_QUERY, &raw mut h_token) {
            CloseHandle(h_token)?;
            return Err(error);
        }

        let mut token_elevation = core::mem::zeroed::<TOKEN_ELEVATION>();
        if let Err(error) = GetTokenInformation(
            h_token,
            TokenElevation,
            Some(core::ptr::addr_of_mut!(token_elevation).cast()),
            u32::try_from(size_of::<TOKEN_ELEVATION>())?,
            &mut 0,
        ) {
            CloseHandle(h_token)?;
            return Err(error);
        }

        CloseHandle(h_token)?;
        Ok(token_elevation.TokenIsElevated != 0)
    }
}

/// # Installs Process Monitor using Winget
/// # Errors
/// Will return `Err` if `Command::spawn` or `Command::wait` fails.
pub fn install_procmon() -> std::io::Result<ExitStatus> {
    Command::new("winget")
        .arg("install")
        .arg("Microsoft.SysInternals.ProcessMonitor")
        .arg("--accept-package-agreements")
        .arg("--accept-source-agreements")
        .arg("--silent")
        .stdout(Stdio::null())
        .spawn()?
        .wait()
}

/// # Starts Process Monitor using the provided program.
/// # Errors
/// Will return `Err` if `Command::spawn` or `Command::wait` fails.
pub fn start_procmon() -> std::io::Result<ExitStatus> {
    std::fs::remove_file(TEMP_DIR_PATH.join(PROCMON_BACKING_NAME))?;

    Command::new("Procmon.exe")
        .arg("/AcceptEula")
        .arg("/BackingFile")
        .arg(TEMP_DIR_PATH.join(PROCMON_BACKING_NAME))
        .arg("/LoadConfig")
        .arg(TEMP_DIR_PATH.join(PROCMON_CONFIG_NAME))
        .arg("/Minimized")
        .arg("/Quiet")
        .spawn()?
        .wait()
}

/// # Processes the Process Monitor capture into CSV.
/// # Errors
/// Will return `Err` if `Command::spawn` or `Command::wait` fails.
pub fn process_procmon() -> std::io::Result<ExitStatus> {
    Command::new("Procmon.exe")
        .arg("/AcceptEula")
        .arg("/OpenLog")
        .arg(TEMP_DIR_PATH.join(PROCMON_BACKING_NAME))
        .arg("/SaveAs")
        .arg(VRCHAT_LOW_PATH.join("Procmon.csv"))
        .arg("/Minimized")
        .arg("/Quiet")
        .spawn()?
        .wait()
}

/// # Terminate Process Monitor.
/// # Errors
/// Will return `Err` if `Command::spawn` or `Command::wait` fails.
pub fn terminate_procmon() -> std::io::Result<ExitStatus> {
    Command::new("Procmon.exe")
        .arg("/AcceptEula")
        .arg("/Minimized")
        .arg("/Quiet")
        .arg("/Terminate")
        .spawn()?
        .wait()
}

/// # Spawns the Process Monitor watcher in a background thread.
/// # Errors
/// Will return `Err` if `tokio::task::spawn_blocking` fails.
pub fn spawn_procmon_watcher() -> JoinHandle<anyhow::Result<()>> {
    tokio::task::spawn_blocking(start_procmon_watcher)
}

/// # Starts the Process Monitor watcher.
/// # Errors
/// Will return `Err` if anything fails.
pub fn start_procmon_watcher() -> anyhow::Result<()> {
    terminate_procmon()?;

    std::fs::write(
        TEMP_DIR_PATH.join(PROCMON_CONFIG_NAME),
        PROCMON_CONFIG_BYTES,
    )?;

    loop {
        if TEMP_DIR_PATH.join(PROCMON_BACKING_NAME).exists() {
            process_procmon()?;
        }

        /* Block until Procmon is closed by the user */
        if let Err(error) = start_procmon() {
            if error.kind() == ErrorKind::NotFound {
                install_procmon()?;
                start_procmon()?;
            } else {
                anyhow::bail!(error)
            }
        }
    }
}