Files
javis_bot/app/src/vdisplay.rs
javis-bot 53bccb620d feat: screen viewing, Jarvis sees the whole screen, a monitor or a window for registered people
- screenView tool (screen_view.spec.md): whole screen, monitor by number, window by part of its
  title or program, or the list of monitors and windows; fast, normal or detailed pictures.
- The app captures with Windows Graphics Capture (app/src/screen.rs, admin.spec.md "Screen
  viewing"), decides for the asker (only people registered for PC control), never picks, lists
  or shows excluded programs (pcControl.screenExclude, password managers by default), refuses
  minimised windows and black pictures, and records screen.view in the activity log.
- Pictures ride on the tool message (ToolExecutionResult.images); llm.py sends them to
  OpenAI-compatible servers as image parts after the tool messages. They stay in that reply only:
  not in the tool carryover, logs or prompt dumps.
- The LLM reads pictures only when screen viewing is available (--vision gpu normally, cpu in a
  game), measured apart for the placement; otherwise screenView is a disabled tool.
- Worker: screen_action / screen_action_result, 4 MiB messages.
- Eval evals/test_screen_view_tool.py; Windows check tests/screen_windows.rs.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-11-15 17:02:59 +09:00

702 lines
33 KiB
Rust

//! The virtual monitor the bot browser's window sits on, so the user can share it in Discord's
//! "Screen" tab while no real monitor shows it (admin.spec.md, "Virtual monitor";
//! `docs/v2/pc-features.md`, "봇용 크롬창과 디스코드 화면공유").
//!
//! The monitor comes from the open-source Virtual Display Driver (MIT, signed by the SignPath
//! Foundation), shipped next to `jarvis.exe` in `display-driver/`. Installing it needs the
//! administrator once (`--display-driver install`, started elevated by the app); turning the monitor
//! on and off does not: the app attaches it to the desktop only while the bot browser uses it.
use std::path::{Path, PathBuf};
use serde::Serialize;
/// The monitor's mode (the driver offers only this one): small enough to share cheaply.
pub const WIDTH: i32 = 1280;
pub const HEIGHT: i32 = 720;
pub const REFRESH: u32 = 30;
/// The adapter name the driver's INF gives its monitors.
pub const ADAPTER_NAME: &str = "Virtual Display Driver";
pub const HARDWARE_ID: &str = "Root\\MttVDD";
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub struct Rect {
pub x: i32,
pub y: i32,
pub w: i32,
pub h: i32,
}
/// Where the virtual monitor goes: right of and below the rightmost real monitor, touching it only
/// at that monitor's bottom-right corner, so the mouse hardly ever wanders onto it and no real
/// monitor overlaps it (nothing reaches further right).
pub fn corner(real: &[Rect]) -> (i32, i32) {
real.iter()
.max_by_key(|r| (r.x + r.w, r.y + r.h))
.map(|r| (r.x + r.w, r.y + r.h))
.unwrap_or((0, 0))
}
/// The driver's settings file: one monitor with one mode, the driver's other options at their
/// defaults.
pub fn settings_xml() -> String {
format!(
"<?xml version='1.0' encoding='utf-8'?>\r\n<vdd_settings>\r\n\
<monitors><count>1</count></monitors>\r\n\
<gpu><friendlyname>default</friendlyname></gpu>\r\n\
<global><g_refresh_rate>{REFRESH}</g_refresh_rate></global>\r\n\
<resolutions><resolution><width>{WIDTH}</width><height>{HEIGHT}</height><refresh_rate>{REFRESH}</refresh_rate></resolution></resolutions>\r\n\
<options><CustomEdid>false</CustomEdid><PreventSpoof>false</PreventSpoof><EdidCeaOverride>false</EdidCeaOverride>\
<HardwareCursor>true</HardwareCursor><SDR10bit>false</SDR10bit><HDRPlus>false</HDRPlus>\
<logging>false</logging><debuglogging>false</debuglogging></options>\r\n</vdd_settings>\r\n"
)
}
/// Where the driver reads its settings: the driver runs as a system service, which cannot read a
/// data folder in the user's profile, so this is the one place outside the data folder.
pub fn config_dir() -> Option<PathBuf> {
std::env::var_os("ProgramData").map(|p| PathBuf::from(p).join("JarvisBot").join("display-driver"))
}
/// The driver files shipped with the app.
pub fn driver_dir() -> Option<PathBuf> {
std::env::current_exe().ok()?.parent().map(|d| d.join("display-driver"))
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize)]
pub struct DriverStatus {
/// Windows only.
pub supported: bool,
/// Installed by this app with its monitor there: usable.
pub installed: bool,
/// Something this app installed is left without a usable monitor (a removal or a failed
/// install's clean-up that did not finish): to be removed.
pub leftover: bool,
/// Another program's copy of the same driver is installed; the app leaves it alone.
pub other: bool,
/// The button the screen offers: `install`, `uninstall` (also for a leftover), or none.
pub action: Option<&'static str>,
}
/// The status from whether the driver is ours (its registry value points at our settings), its
/// monitor is there, and any of its devices is.
#[cfg_attr(not(windows), allow(dead_code))]
fn driver_status(ours: bool, monitor: bool, devices: bool) -> DriverStatus {
let installed = ours && monitor;
let leftover = ours && !installed;
let other = (monitor || devices) && !ours;
let action = if ours { Some("uninstall") } else if other { None } else { Some("install") };
DriverStatus { supported: true, installed, leftover, other, action }
}
/// After a failed install: whether to forget the driver (its registry value and settings folder)
/// and what to report. Only an attempt that was not ours before and left no device and no package
/// (1168: not in the driver store) is forgotten; otherwise it stays ours so the screen can remove
/// what is left.
#[cfg_attr(not(windows), allow(dead_code))]
fn after_failed_install(failure: String, was_ours: bool, devices_left: usize, package: Result<(), u32>) -> (bool, String) {
match removal_done(devices_left, package) {
Ok(()) => (!was_ours, failure),
Err(e) => (false, format!("{failure}. 정리하지 못한 것이 남아 있으니 제거를 눌러 주세요 ({e})")),
}
}
#[cfg(not(windows))]
pub fn status() -> DriverStatus {
DriverStatus { supported: false, installed: false, leftover: false, other: false, action: None }
}
#[cfg(not(windows))]
pub fn attach() -> Result<Rect, String> {
Err("가상 모니터는 Windows에서만 씁니다".into())
}
#[cfg(not(windows))]
pub fn detach() {}
#[cfg(not(windows))]
pub fn settle_windows(_pid: u32) -> usize {
0
}
#[cfg(not(windows))]
pub async fn run_elevated(_action: &str) -> Result<(), String> {
Err("가상 모니터는 Windows에서만 씁니다".into())
}
/// The elevated half's exit code when removing finds no driver of this app's (none, or another
/// program's copy): the uninstaller goes on. 0 is done, 1 failed (the uninstaller stops).
pub const NOTHING_TO_REMOVE: i32 = 2;
/// `jarvis.exe --display-driver install|uninstall --result FILE`: the elevated half of
/// `run_elevated`; the outcome (empty, or why it failed) goes to FILE. `None` without the option.
pub fn elevated_main(args: &[String]) -> Option<i32> {
let i = args.iter().position(|a| a == "--display-driver")?;
let action = args.get(i + 1).map(String::as_str).unwrap_or("");
let result = args.iter().position(|a| a == "--result").and_then(|j| args.get(j + 1)).map(PathBuf::from);
if action == "uninstall" && !owns_driver() {
if let Some(f) = &result {
let _ = std::fs::write(f, "");
}
return Some(NOTHING_TO_REMOVE);
}
let outcome = match (action, driver_dir()) {
(_, None) => Err("앱 폴더를 찾지 못했습니다".to_owned()),
("install", Some(d)) => install(&d),
("uninstall", Some(d)) => uninstall(&d),
_ => Err(format!("알 수 없는 동작: {action}")),
};
if let Some(f) = result {
let _ = std::fs::write(f, outcome.as_ref().err().map(String::as_str).unwrap_or(""));
}
Some(if outcome.is_ok() { 0 } else { 1 })
}
/// Whether this app's driver (or something it left) is on the PC.
fn owns_driver() -> bool {
#[cfg(windows)]
return win::ours();
#[cfg(not(windows))]
false
}
#[cfg(not(windows))]
fn install(_driver: &Path) -> Result<(), String> {
Err("가상 모니터는 Windows에서만 씁니다".into())
}
#[cfg(not(windows))]
fn uninstall(_driver: &Path) -> Result<(), String> {
Err("가상 모니터는 Windows에서만 씁니다".into())
}
#[cfg(windows)]
pub use win::{attach, detach, run_elevated, settle_windows, status, virtual_display_name};
#[cfg(windows)]
use win::{install, uninstall};
#[cfg(windows)]
mod win {
use super::*;
use std::os::windows::ffi::OsStrExt;
use windows_sys::core::BOOL;
use windows_sys::Win32::Devices::DeviceAndDriverInstallation::*;
use windows_sys::Win32::Foundation::*;
use windows_sys::Win32::Graphics::Gdi::*;
use windows_sys::Win32::System::Registry::{RegGetValueW, HKEY_LOCAL_MACHINE, RRF_RT_REG_SZ};
use windows_sys::Win32::System::Threading::{GetExitCodeProcess, WaitForSingleObject, INFINITE};
use windows_sys::Win32::UI::Shell::{ShellExecuteExW, SEE_MASK_NOCLOSEPROCESS, SHELLEXECUTEINFOW};
use windows_sys::Win32::UI::WindowsAndMessaging::*;
const REG_KEY: &str = "SOFTWARE\\MikeTheTech\\VirtualDisplayDriver";
fn wide(s: &str) -> Vec<u16> {
s.encode_utf16().chain(Some(0)).collect()
}
fn wide_path(p: &Path) -> Vec<u16> {
p.as_os_str().encode_wide().chain(Some(0)).collect()
}
fn text(buf: &[u16]) -> String {
String::from_utf16_lossy(&buf[..buf.iter().position(|&c| c == 0).unwrap_or(buf.len())])
}
struct Device {
name: [u16; 32],
string: String,
attached: bool,
}
fn devices() -> Vec<Device> {
let mut out = vec![];
for i in 0.. {
let mut dd = DISPLAY_DEVICEW { cb: std::mem::size_of::<DISPLAY_DEVICEW>() as u32, ..Default::default() };
// SAFETY: `dd` is a DISPLAY_DEVICEW with its size set, as the call requires.
if unsafe { EnumDisplayDevicesW(std::ptr::null(), i, &mut dd, 0) } == 0 {
break;
}
out.push(Device { name: dd.DeviceName, string: text(&dd.DeviceString),
attached: dd.StateFlags & DISPLAY_DEVICE_ATTACHED_TO_DESKTOP != 0 });
}
out
}
fn current(name: &[u16; 32]) -> Option<Rect> {
let mut dm = DEVMODEW { dmSize: std::mem::size_of::<DEVMODEW>() as u16, ..Default::default() };
// SAFETY: `name` is NUL-terminated (from EnumDisplayDevicesW) and `dm` has its size set.
if unsafe { EnumDisplaySettingsExW(name.as_ptr(), ENUM_CURRENT_SETTINGS, &mut dm, 0) } == 0 {
return None;
}
// SAFETY: for a display, the position variant of the union is the one Windows fills.
let pos = unsafe { dm.Anonymous1.Anonymous2.dmPosition };
Some(Rect { x: pos.x, y: pos.y, w: dm.dmPelsWidth as i32, h: dm.dmPelsHeight as i32 })
}
/// Put the display at `rect`, or take it off the desktop with `None`, and keep that.
fn set_mode(name: &[u16; 32], rect: Option<Rect>) -> Result<(), String> {
let mut dm = DEVMODEW { dmSize: std::mem::size_of::<DEVMODEW>() as u16, ..Default::default() };
// SAFETY: as in `current`; a failure leaves `dm` zeroed, which the fields below complete.
unsafe { EnumDisplaySettingsExW(name.as_ptr(), ENUM_REGISTRY_SETTINGS, &mut dm, 0) };
let r = rect.unwrap_or(Rect { x: 0, y: 0, w: 0, h: 0 });
dm.dmFields = DM_POSITION | DM_PELSWIDTH | DM_PELSHEIGHT;
dm.Anonymous1.Anonymous2 = DEVMODEW_0_1 { dmPosition: POINTL { x: r.x, y: r.y }, ..Default::default() };
dm.dmPelsWidth = r.w as u32;
dm.dmPelsHeight = r.h as u32;
// SAFETY: valid NUL-terminated device name and DEVMODEW; null window and parameter.
let changed = unsafe {
ChangeDisplaySettingsExW(name.as_ptr(), &dm, std::ptr::null_mut(), CDS_UPDATEREGISTRY | CDS_NORESET, std::ptr::null())
};
// SAFETY: the documented "apply the stored changes" call: all null, no flags.
let applied = unsafe { ChangeDisplaySettingsExW(std::ptr::null(), std::ptr::null(), std::ptr::null_mut(), 0, std::ptr::null()) };
if changed != DISP_CHANGE_SUCCESSFUL || applied != DISP_CHANGE_SUCCESSFUL {
return Err(format!("화면 설정을 바꾸지 못했습니다 ({changed}, {applied})"));
}
Ok(())
}
fn vdd_path() -> Option<String> {
let mut buf = [0u16; 520];
let mut size = (buf.len() * 2) as u32;
let (key, value) = (wide(REG_KEY), wide("VDDPATH"));
// SAFETY: valid NUL-terminated strings; `buf` holds `size` bytes.
let r = unsafe {
RegGetValueW(HKEY_LOCAL_MACHINE, key.as_ptr(), value.as_ptr(), RRF_RT_REG_SZ, std::ptr::null_mut(),
buf.as_mut_ptr().cast(), &mut size)
};
(r == ERROR_SUCCESS).then(|| text(&buf))
}
pub(super) fn ours() -> bool {
match (vdd_path(), config_dir()) {
(Some(p), Some(c)) => p.trim_end_matches('\\').eq_ignore_ascii_case(c.to_string_lossy().trim_end_matches('\\')),
_ => false,
}
}
fn adapter() -> Option<Device> {
devices().into_iter().find(|d| d.string == ADAPTER_NAME)
}
/// Installed means ours with its monitor there (the driver loaded); ours without it is a
/// leftover the screen offers to remove.
pub fn status() -> DriverStatus {
driver_status(ours(), adapter().is_some(), !hardware_devices().is_empty())
}
/// Put the virtual monitor on the desktop at `corner` and return where it is.
pub fn attach() -> Result<Rect, String> {
if !ours() {
return Err("가상 모니터 드라이버가 설치되지 않았습니다".into());
}
let v = adapter().ok_or("가상 모니터를 찾지 못했습니다")?;
let real: Vec<Rect> = devices().iter().filter(|d| d.attached && d.string != ADAPTER_NAME)
.filter_map(|d| current(&d.name)).collect();
let (x, y) = corner(&real);
set_mode(&v.name, Some(Rect { x, y, w: WIDTH, h: HEIGHT }))?;
current(&v.name).filter(|r| r.w > 0).ok_or_else(|| "가상 모니터가 켜지지 않았습니다".into())
}
/// The virtual monitor's display name (`\\.\DISPLAY<n>`) while it is on the desktop: screen
/// viewing leaves it out (admin.spec.md, "Screen viewing").
pub fn virtual_display_name() -> Option<String> {
adapter().filter(|d| d.attached).map(|d| text(&d.name))
}
/// Take the virtual monitor off the desktop (when it is ours and on it).
pub fn detach() {
if !ours() {
return;
}
if let Some(v) = adapter().filter(|d| d.attached) {
if let Err(e) = set_mode(&v.name, None) {
crate::warn_log!("browser", "Warning: the virtual monitor stays on: {e}");
}
}
}
struct Found {
pid: u32,
windows: Vec<HWND>,
}
unsafe extern "system" fn collect(hwnd: HWND, lparam: LPARAM) -> BOOL {
// SAFETY: `lparam` is the `Found` that `settle_windows` passes and outlives EnumWindows.
let found = unsafe { &mut *(lparam as *mut Found) };
let mut pid = 0u32;
let mut class = [0u16; 64];
// SAFETY: plain queries on a window handle EnumWindows gave; buffers are sized as passed.
unsafe {
GetWindowThreadProcessId(hwnd, &mut pid);
if pid == found.pid && IsWindowVisible(hwnd) != 0 && GetWindow(hwnd, GW_OWNER).is_null()
&& GetClassNameW(hwnd, class.as_mut_ptr(), class.len() as i32) > 0 && text(&class) == "Chrome_WidgetWin_1" {
found.windows.push(hwnd);
}
}
1
}
/// Make process `pid`'s new top-level Chrome windows tool windows (not in Alt+Tab, Win+Tab or
/// the taskbar) and fill their monitor's work area (Windows may give the virtual monitor a
/// taskbar of its own, which would cover the page's bottom), all without activating them. The
/// bot's windows stay behind all others, the newest in front of the older ones. Returns how many
/// windows were new.
pub fn settle_windows(pid: u32) -> usize {
let mut found = Found { pid, windows: vec![] };
// SAFETY: `collect` only reads windows and writes into `found`, which lives through the call.
unsafe { EnumWindows(Some(collect), &mut found as *mut Found as LPARAM) };
// SAFETY: a plain query on a window handle EnumWindows gave.
let (old, new): (Vec<HWND>, Vec<HWND>) = found.windows.into_iter()
.partition(|&h| unsafe { GetWindowLongPtrW(h, GWL_EXSTYLE) } as u32 & WS_EX_TOOLWINDOW != 0);
for &h in &new {
// SAFETY: style changes on a window of our own child process; hiding and showing it
// again is what makes the taskbar notice the new style.
unsafe {
let ex = GetWindowLongPtrW(h, GWL_EXSTYLE) as u32;
ShowWindow(h, SW_HIDE);
SetWindowLongPtrW(h, GWL_EXSTYLE, ((ex | WS_EX_TOOLWINDOW) & !WS_EX_APPWINDOW) as isize);
ShowWindow(h, SW_SHOWNOACTIVATE);
let mut mi = MONITORINFO { cbSize: std::mem::size_of::<MONITORINFO>() as u32, ..Default::default() };
if GetMonitorInfoW(MonitorFromWindow(h, MONITOR_DEFAULTTONEAREST), &mut mi) != 0 {
let w = mi.rcWork;
SetWindowPos(h, HWND_BOTTOM, w.left, w.top, w.right - w.left, w.bottom - w.top, SWP_NOACTIVATE);
} else {
SetWindowPos(h, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);
}
}
}
if !new.is_empty() {
// Top first, each to the bottom: they keep their order, all behind the new ones.
for &h in &old {
// SAFETY: a z-order change of our own child process's window, without activating it.
unsafe { SetWindowPos(h, HWND_BOTTOM, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE) };
}
}
new.len()
}
/// The root devices with the driver's hardware ID, in any class (a device whose driver install
/// was declined has none), present or not.
fn hardware_devices() -> Vec<SP_DEVINFO_DATA> {
let (set, list) = hardware_set();
if set != INVALID_HANDLE_VALUE as HDEVINFO {
// SAFETY: the list from `hardware_set`, no longer used.
unsafe { SetupDiDestroyDeviceInfoList(set) };
}
list
}
fn hardware_set() -> (HDEVINFO, Vec<SP_DEVINFO_DATA>) {
let root = wide("ROOT");
let flags = DIGCF_ALLCLASSES;
// SAFETY: a device list of the root enumerator; destroyed by the callers that keep it.
let set = unsafe { SetupDiGetClassDevsW(std::ptr::null(), root.as_ptr(), std::ptr::null_mut(), flags) };
let mut out = vec![];
if set == INVALID_HANDLE_VALUE as HDEVINFO {
return (set, out);
}
for i in 0.. {
let mut di = SP_DEVINFO_DATA { cbSize: std::mem::size_of::<SP_DEVINFO_DATA>() as u32, ..Default::default() };
// SAFETY: `di` has its size set; the loop ends at the first index past the list.
if unsafe { SetupDiEnumDeviceInfo(set, i, &mut di) } == 0 {
break;
}
let mut buf = [0u16; 256];
// SAFETY: `buf` holds the byte count passed.
let ok = unsafe {
SetupDiGetDeviceRegistryPropertyW(set, &di, SPDRP_HARDWAREID, std::ptr::null_mut(), buf.as_mut_ptr().cast(),
(buf.len() * 2) as u32, std::ptr::null_mut())
};
if ok != 0 && text(&buf).eq_ignore_ascii_case(HARDWARE_ID) {
out.push(di);
}
}
(set, out)
}
fn run(cmd: &str, args: &[&str]) -> Result<(), String> {
use std::os::windows::process::CommandExt;
let s = std::process::Command::new(cmd).args(args).creation_flags(0x0800_0000)
.stdout(std::process::Stdio::null()).stderr(std::process::Stdio::null()).status()
.map_err(|e| format!("{cmd}: {e}"))?;
if s.success() { Ok(()) } else { Err(format!("{cmd} failed ({s})")) }
}
/// Elevated: settings folder, the driver's registry value, the device, and its driver. Windows
/// asks the user once whether to install software from the SignPath Foundation. A failure (also
/// the user saying no) undoes what this attempt made, so nothing looks installed and the next
/// attempt starts clean.
pub(super) fn install(driver: &Path) -> Result<(), String> {
let inf = driver.join("MttVDD.inf");
if !inf.is_file() {
return Err("드라이버 파일이 없습니다 (display-driver\\MttVDD.inf)".into());
}
let (was_ours, had_device) = (ours(), !hardware_devices().is_empty());
if (had_device || adapter().is_some()) && !was_ours {
return Err("다른 프로그램이 설치한 가상 디스플레이 드라이버가 이미 있습니다".into());
}
let Err(failure) = install_steps(&inf, had_device) else { return Ok(()) };
let left = if had_device { 0 } else { remove_devices() };
let package = if was_ours || left > 0 { Ok(()) } else { uninstall_package(&inf) };
let (forget, why) = after_failed_install(failure, was_ours, left, package);
if forget {
let _ = run("reg", &["delete", &format!("HKLM\\{REG_KEY}"), "/f"]);
remove_config_dir();
}
Err(why)
}
fn install_steps(inf: &Path, had_device: bool) -> Result<(), String> {
let dir = config_dir().ok_or("ProgramData 폴더를 찾지 못했습니다")?;
std::fs::create_dir_all(&dir).map_err(|e| e.to_string())?;
std::fs::write(dir.join("vdd_settings.xml"), settings_xml()).map_err(|e| e.to_string())?;
// Only the system, administrators, the driver's service account (LOCAL SERVICE) and users
// reading: no user can change what the driver reads.
let d = dir.to_string_lossy().into_owned();
run("icacls", &[&d, "/inheritance:r", "/grant:r", "*S-1-5-18:(OI)(CI)F", "*S-1-5-32-544:(OI)(CI)F",
"*S-1-5-19:(OI)(CI)RX", "*S-1-5-32-545:(OI)(CI)RX"])?;
run("reg", &["add", &format!("HKLM\\{REG_KEY}"), "/v", "VDDPATH", "/t", "REG_SZ", "/d", &d, "/f"])?;
if !had_device {
create_device()?;
}
let (hw, inf_w) = (wide(HARDWARE_ID), wide_path(inf));
let mut reboot: BOOL = 0;
// SAFETY: valid NUL-terminated strings; no parent window.
if unsafe { UpdateDriverForPlugAndPlayDevicesW(std::ptr::null_mut(), hw.as_ptr(), inf_w.as_ptr(), INSTALLFLAG_FORCE, &mut reboot) } == 0 {
// SAFETY: plain call.
let e = unsafe { GetLastError() };
// No to Windows' question about the publisher comes back as "publisher not trusted".
const PUBLISHER_NOT_TRUSTED: u32 = 0xE000_0243;
return Err(if e == ERROR_CANCELLED || e == PUBLISHER_NOT_TRUSTED { "드라이버 설치를 취소했습니다".into() }
else { format!("드라이버를 설치하지 못했습니다 ({e})") });
}
// The new monitor joins the desktop at once; it stays off until the bot browser uses it.
for _ in 0..50 {
if adapter().is_some_and(|a| a.attached) {
detach();
break;
}
std::thread::sleep(std::time::Duration::from_millis(200));
}
Ok(())
}
/// Remove every device with the driver's hardware ID; returns how many are left.
fn remove_devices() -> usize {
let (set, list) = hardware_set();
for di in &list {
// SAFETY: removing a device of the list `set`, which is destroyed after the loop.
unsafe { SetupDiCallClassInstaller(DIF_REMOVE, set, di) };
}
if set != INVALID_HANDLE_VALUE as HDEVINFO {
// SAFETY: the list from `hardware_set`.
unsafe { SetupDiDestroyDeviceInfoList(set) };
}
hardware_devices().len()
}
/// Remove the driver package from the driver store; `Err` with the Windows error code.
fn uninstall_package(inf: &Path) -> Result<(), u32> {
let inf = wide_path(inf);
let mut reboot: BOOL = 0;
// SAFETY: valid NUL-terminated path; no parent window.
if unsafe { DiUninstallDriverW(std::ptr::null_mut(), inf.as_ptr(), 0, &mut reboot) } != 0 {
return Ok(());
}
// SAFETY: plain call.
Err(unsafe { GetLastError() })
}
fn remove_config_dir() {
if let Some(dir) = config_dir() {
let _ = std::fs::remove_dir_all(&dir);
if let Some(parent) = dir.parent() {
let _ = std::fs::remove_dir(parent);
}
}
}
fn create_device() -> Result<(), String> {
let (name, hw) = (wide("Display"), {
let mut v: Vec<u16> = HARDWARE_ID.encode_utf16().collect();
v.extend([0, 0]);
v
});
// SAFETY: the devcon "install" sequence: a list, one generated device with the hardware ID,
// registered with the class installer; the list is destroyed on every path.
unsafe {
let set = SetupDiCreateDeviceInfoList(&GUID_DEVCLASS_DISPLAY, std::ptr::null_mut());
if set == INVALID_HANDLE_VALUE as HDEVINFO {
return Err(format!("장치 목록을 만들지 못했습니다 ({})", GetLastError()));
}
let mut di = SP_DEVINFO_DATA { cbSize: std::mem::size_of::<SP_DEVINFO_DATA>() as u32, ..Default::default() };
let ok = SetupDiCreateDeviceInfoW(set, name.as_ptr(), &GUID_DEVCLASS_DISPLAY, std::ptr::null(), std::ptr::null_mut(), DICD_GENERATE_ID, &mut di) != 0
&& SetupDiSetDeviceRegistryPropertyW(set, &mut di, SPDRP_HARDWAREID, hw.as_ptr().cast(), (hw.len() * 2) as u32) != 0
&& SetupDiCallClassInstaller(DIF_REGISTERDEVICE, set, &di) != 0;
let e = GetLastError();
SetupDiDestroyDeviceInfoList(set);
if ok { Ok(()) } else { Err(format!("가상 모니터 장치를 만들지 못했습니다 ({e})")) }
}
}
/// Elevated: remove the device, the driver, the registry value and the settings folder; only
/// when this app installed it. The registry value (what makes it ours) goes only once the
/// device and the driver are gone, so a failed removal can be retried.
pub(super) fn uninstall(driver: &Path) -> Result<(), String> {
if !ours() {
return Err("이 앱이 설치한 가상 디스플레이 드라이버가 아닙니다".into());
}
let left = remove_devices();
let package = if left == 0 { uninstall_package(&driver.join("MttVDD.inf")) } else { Ok(()) };
removal_done(left, package)?;
run("reg", &["delete", &format!("HKLM\\{REG_KEY}"), "/f"])
.map_err(|e| format!("드라이버 등록 정보를 지우지 못했습니다: {e}"))?;
remove_config_dir();
Ok(())
}
/// Run `jarvis.exe --display-driver <action>` as administrator (Windows asks the user) and wait.
pub async fn run_elevated(action: &str) -> Result<(), String> {
let exe = std::env::current_exe().map_err(|e| e.to_string())?;
let result = std::env::temp_dir().join(format!("jarvis-display-{}.txt", std::process::id()));
let _ = std::fs::remove_file(&result);
let params = format!("--display-driver {action} --result \"{}\"", result.display());
let code = tokio::task::spawn_blocking(move || -> Result<u32, String> {
let (verb, file, params) = (wide("runas"), wide_path(&exe), wide(&params));
// SAFETY: SHELLEXECUTEINFOW is plain data; all zero is its documented empty state.
let mut info: SHELLEXECUTEINFOW = unsafe { std::mem::zeroed() };
info.cbSize = std::mem::size_of::<SHELLEXECUTEINFOW>() as u32;
info.fMask = SEE_MASK_NOCLOSEPROCESS;
info.lpVerb = verb.as_ptr();
info.lpFile = file.as_ptr();
info.lpParameters = params.as_ptr();
info.nShow = SW_HIDE;
// SAFETY: `info` is filled as documented and its strings live through the call; the
// process handle it returns is waited on and closed here.
unsafe {
if ShellExecuteExW(&mut info) == 0 {
let e = GetLastError();
return Err(if e == ERROR_CANCELLED { "관리자 권한을 받지 못했습니다".into() } else { format!("관리자 권한으로 실행하지 못했습니다 ({e})") });
}
WaitForSingleObject(info.hProcess, INFINITE);
let mut code = 1u32;
GetExitCodeProcess(info.hProcess, &mut code);
CloseHandle(info.hProcess);
Ok(code)
}
}).await.map_err(|e| e.to_string())??;
let why = std::fs::read_to_string(&result).unwrap_or_default();
let _ = std::fs::remove_file(&result);
match code {
0 => Ok(()),
c if c as i32 == super::NOTHING_TO_REMOVE && action == "uninstall" => Ok(()),
_ if !why.is_empty() => Err(why),
c => Err(format!("드라이버 작업이 실패했습니다 (종료 코드 {c})")),
}
}
}
/// Whether a removal may forget the driver was ours: no device left, and the driver package
/// removed or not in the driver store (Windows error 1168, ERROR_NOT_FOUND).
#[cfg_attr(not(windows), allow(dead_code))]
fn removal_done(devices_left: usize, package: Result<(), u32>) -> Result<(), String> {
if devices_left > 0 {
return Err(format!("가상 모니터 장치 {devices_left}개를 지우지 못했습니다. 다시 시도해 주세요"));
}
match package {
Ok(()) | Err(1168) => Ok(()),
Err(e) => Err(format!("드라이버 패키지를 지우지 못했습니다 ({e}). 다시 시도해 주세요")),
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn a_failed_install_forgets_the_driver_only_when_its_leftovers_are_gone() {
let declined = || "드라이버 설치를 취소했습니다".to_owned();
// Cleaned up: forgotten (when it was not ours before), the failure reported as it was.
assert_eq!(after_failed_install(declined(), false, 0, Err(1168)), (true, declined()));
// A device left: kept ours, so the leftover can be removed; both reasons reported.
let (forget, why) = after_failed_install(declined(), false, 1, Ok(()));
assert!(!forget, "a device left keeps the registry value");
assert!(why.starts_with(&declined()) && why.contains("제거"), "{why}");
// A package left: the same.
let (forget, why) = after_failed_install(declined(), false, 0, Err(5));
assert!(!forget);
assert!(why.contains("제거"), "{why}");
// Ours before the attempt: never forgotten by a failed reinstall.
assert!(!after_failed_install(declined(), true, 0, Ok(())).0);
}
#[test]
fn what_is_left_of_the_driver_can_always_be_removed_from_the_screen() {
// Installed and working: remove.
let s = driver_status(true, true, true);
assert!(s.installed && !s.leftover && !s.other);
assert_eq!(s.action, Some("uninstall"));
// Device gone but the package (and the registry value) left after a failed removal.
let s = driver_status(true, false, false);
assert!(!s.installed && s.leftover);
assert_eq!(s.action, Some("uninstall"), "the leftover can be removed again");
// Nothing of ours: install. Another program's copy: nothing to press.
assert_eq!(driver_status(false, false, false).action, Some("install"));
let s = driver_status(false, true, true);
assert!(s.other && !s.installed && !s.leftover);
assert_eq!(s.action, None);
}
#[test]
fn a_removal_forgets_the_driver_only_when_device_and_package_are_gone() {
assert_eq!(removal_done(0, Ok(())), Ok(()));
assert_eq!(removal_done(0, Err(1168)), Ok(()), "a package not in the store is already gone");
assert!(removal_done(1, Ok(())).is_err(), "a device left keeps it ours, so it can be retried");
assert!(removal_done(0, Err(5)).is_err());
}
#[test]
fn the_monitor_touches_the_rightmost_monitor_only_at_its_corner() {
let one = [Rect { x: 0, y: 0, w: 1920, h: 1080 }];
assert_eq!(corner(&one), (1920, 1080));
// A second monitor left of the main one, and one above-right: the rightmost decides.
let three = [Rect { x: 0, y: 0, w: 2560, h: 1440 }, Rect { x: -1920, y: 0, w: 1920, h: 1080 },
Rect { x: 2560, y: -400, w: 1080, h: 1920 }];
let (x, y) = corner(&three);
assert_eq!((x, y), (3640, 1520));
for r in &three {
assert!(r.x + r.w <= x, "no real monitor reaches into the virtual one");
}
// Two equally far right: the lower corner, so neither overlaps.
let stacked = [Rect { x: 0, y: 0, w: 1920, h: 1080 }, Rect { x: 0, y: 1080, w: 1920, h: 1080 }];
assert_eq!(corner(&stacked), (1920, 2160));
}
#[test]
fn the_driver_gets_one_monitor_with_the_one_mode() {
let x = settings_xml();
assert!(x.contains("<count>1</count>"));
assert!(x.contains(&format!("<width>{WIDTH}</width><height>{HEIGHT}</height><refresh_rate>{REFRESH}</refresh_rate>")));
assert_eq!(x.matches("<resolution>").count(), 1);
assert!(x.contains("<CustomEdid>false</CustomEdid>"), "the driver never loads an EDID file from its folder");
}
#[test]
fn only_the_display_driver_option_runs_the_elevated_half() {
assert_eq!(elevated_main(&["jarvis".into(), "--location".into(), "x".into()]), None);
}
#[test]
fn removing_a_driver_this_app_does_not_own_says_there_is_nothing_to_remove() {
// The uninstaller goes on with code 2, and stops on a failure (code 1).
let result = std::env::temp_dir().join(format!("jarvis-vdd-test-{}.txt", std::process::id()));
let args: Vec<String> = ["jarvis", "--display-driver", "uninstall", "--result", result.to_str().unwrap()]
.map(String::from).into();
assert_eq!(elevated_main(&args), Some(NOTHING_TO_REMOVE));
assert_eq!(std::fs::read_to_string(&result).unwrap(), "");
let _ = std::fs::remove_file(&result);
let bad: Vec<String> = ["jarvis", "--display-driver", "nope"].map(String::from).into();
assert_eq!(elevated_main(&bad), Some(1));
}
}