Initial commit

This commit is contained in:
Xuc Pan committed 2026-09-05 13:04:29 +08:00
commit 611383544b
91 files changed
+12958

No files matched your search

+537
View File
@@ -0,0 +1,537 @@
use anyhow::{Context, Result};
use input_linux_sys as linux;
use std::collections::HashSet;
use std::fs::{File, OpenOptions};
use std::io::Write;
use std::os::unix::io::AsRawFd;
use super::InputBackend;
// /dev/uinput interface constants (linux/uinput.h, linux/input-event-codes.h)
const UI_SET_EVBIT: libc::Ioctl = 0x4004_5564_u64 as libc::Ioctl;
const UI_SET_KEYBIT: libc::Ioctl = 0x4004_5565_u64 as libc::Ioctl;
const UI_SET_RELBIT: libc::Ioctl = 0x4004_5566_u64 as libc::Ioctl;
const UI_SET_ABSBIT: libc::Ioctl = 0x4004_5567_u64 as libc::Ioctl;
// struct uinput_setup = name[80] + input_id(8) + ff_effects_max(4) = 92 bytes
const UI_DEV_SETUP: libc::Ioctl = 0x405C_5503_u64 as libc::Ioctl;
// struct uinput_abs_setup = u16 code + input_absinfo(24) = 28 bytes
const UI_ABS_SETUP: libc::Ioctl = 0x401C_5504_u64 as libc::Ioctl;
const UI_DEV_CREATE: libc::Ioctl = 0x5501_u64 as libc::Ioctl;
const UI_DEV_DESTROY: libc::Ioctl = 0x5502_u64 as libc::Ioctl;
const EV_SYN: u16 = 0x00;
const EV_KEY: u16 = 0x01;
const EV_REL: u16 = 0x02;
const EV_ABS: u16 = 0x03;
const SYN_REPORT: u16 = 0;
const REL_X: u16 = 0x00;
const REL_Y: u16 = 0x01;
const REL_WHEEL: u16 = 0x08;
const REL_HWHEEL: u16 = 0x09;
const ABS_X: u16 = 0x00;
const ABS_Y: u16 = 0x01;
const BTN_LEFT: u16 = 0x110;
const BTN_RIGHT: u16 = 0x111;
const BTN_MIDDLE: u16 = 0x112;
const BTN_SIDE: u16 = 0x116;
const BTN_EXTRA: u16 = 0x117;
const BTN_TOOL_PEN: u16 = 0x140;
const BUS_VIRTUAL: u16 = 0x06;
/// struct input_event, 64-bit time_t layout.
#[repr(C)]
struct InputEvent {
tv_sec: i64,
tv_usec: i64,
type_: u16,
code: u16,
value: i32,
}
/// struct uinput_setup: name[80] + input_id(4×u16) + ff_effects_max(u32).
#[repr(C)]
struct UinputSetup {
name: [u8; 80],
bustype: u16,
vendor: u16,
product: u16,
version: u16,
ff_effects_max: u32,
}
/// struct uinput_abs_setup: u16 code (+padding) + input_absinfo (6×i32).
#[repr(C)]
struct UinputAbsSetup {
code: u16,
pad: u16,
value: i32,
minimum: i32,
maximum: i32,
fuzz: i32,
flat: i32,
resolution: i32,
}
fn open_device() -> Result<File> {
OpenOptions::new()
.write(true)
.open("/dev/uinput")
.context("opening /dev/uinput")
}
fn ioctl_u32(file: &File, request: libc::Ioctl, value: u32) -> Result<()> {
let rc = unsafe { libc::ioctl(file.as_raw_fd(), request, value) };
if rc < 0 {
return Err(std::io::Error::last_os_error()).context("uinput ioctl");
}
Ok(())
}
/// One kernel virtual input device.
struct UinputDevice {
file: File,
}
impl UinputDevice {
fn create(name: &'static str, product: u16) -> Result<Self> {
let file = open_device()?;
unsafe {
let mut setup_name = [0u8; 80];
let label = name.as_bytes();
let len = label.len().min(79);
setup_name[..len].copy_from_slice(&label[..len]);
let rc = libc::ioctl(
file.as_raw_fd(),
UI_DEV_SETUP,
&UinputSetup {
name: setup_name,
bustype: BUS_VIRTUAL,
vendor: 0x1,
product,
version: 1,
ff_effects_max: 0,
},
);
if rc < 0 {
return Err(std::io::Error::last_os_error()).context("uinput UI_DEV_SETUP");
}
}
Ok(Self { file })
}
fn keybit(&self, code: u16) -> Result<()> {
ioctl_u32(&self.file, UI_SET_KEYBIT, code as u32)
}
fn relbit(&self, code: u16) -> Result<()> {
ioctl_u32(&self.file, UI_SET_RELBIT, code as u32)
}
fn absbit(&self, code: u16, maximum: i32) -> Result<()> {
ioctl_u32(&self.file, UI_SET_ABSBIT, code as u32)?;
let setup = UinputAbsSetup {
code,
pad: 0,
value: 0,
minimum: 0,
maximum,
fuzz: 0,
flat: 0,
resolution: 0,
};
let rc = unsafe { libc::ioctl(self.file.as_raw_fd(), UI_ABS_SETUP, &setup) };
if rc < 0 {
return Err(std::io::Error::last_os_error()).context("uinput UI_ABS_SETUP");
}
Ok(())
}
fn finish(&self) -> Result<()> {
let rc = unsafe { libc::ioctl(self.file.as_raw_fd(), UI_DEV_CREATE) };
if rc < 0 {
return Err(std::io::Error::last_os_error()).context("uinput UI_DEV_CREATE");
}
Ok(())
}
fn emit(&self, type_: u16, code: u16, value: i32) -> Result<()> {
let event = InputEvent {
tv_sec: 0,
tv_usec: 0,
type_,
code,
value,
};
let bytes = unsafe {
std::slice::from_raw_parts(
&event as *const InputEvent as *const u8,
std::mem::size_of::<InputEvent>(),
)
};
// File implements Write through a shared reference.
let mut file = &self.file;
file.write_all(bytes)?;
Ok(())
}
fn syn(&self) -> Result<()> {
self.emit(EV_SYN, SYN_REPORT, 0)
}
}
impl Drop for UinputDevice {
fn drop(&mut self) {
unsafe {
libc::ioctl(self.file.as_raw_fd(), UI_DEV_DESTROY);
}
}
}
/// Kernel-level input injection through /dev/uinput. Works identically on
/// every Wayland compositor and every X11 session, because the events enter
/// the input stack like real hardware. Requires write access to
/// /dev/uinput (udev `uaccess` tag or the `input` group).
///
/// Devices are deliberately split so libinput classifies each one cleanly:
/// mixing REL and ABS axes on one device makes compositors treat it as a
/// mouse and silently drop its absolute events (verified on KWin).
struct Devices {
keyboard: UinputDevice,
pointer: UinputDevice,
tablet: UinputDevice,
}
impl Devices {
fn create() -> Result<Self> {
let keyboard = UinputDevice::create("uur virtual keyboard", 1)?;
ioctl_u32(&keyboard.file, UI_SET_EVBIT, EV_KEY as u32)?;
ioctl_u32(&keyboard.file, UI_SET_EVBIT, EV_SYN as u32)?;
for code in 1..=0xffu16 {
keyboard.keybit(code)?;
}
keyboard.finish()?;
let pointer = UinputDevice::create("uur virtual pointer", 2)?;
ioctl_u32(&pointer.file, UI_SET_EVBIT, EV_KEY as u32)?;
ioctl_u32(&pointer.file, UI_SET_EVBIT, EV_REL as u32)?;
ioctl_u32(&pointer.file, UI_SET_EVBIT, EV_SYN as u32)?;
for button in [BTN_LEFT, BTN_RIGHT, BTN_MIDDLE, BTN_SIDE, BTN_EXTRA] {
pointer.keybit(button)?;
}
for rel in [REL_X, REL_Y, REL_WHEEL, REL_HWHEEL] {
pointer.relbit(rel)?;
}
pointer.finish()?;
// An absolute pointer must look like a pen tablet, otherwise
// libinput treats it as a mouse and ignores absolute motion.
let tablet = UinputDevice::create("uur virtual tablet", 3)?;
ioctl_u32(&tablet.file, UI_SET_EVBIT, EV_KEY as u32)?;
ioctl_u32(&tablet.file, UI_SET_EVBIT, EV_ABS as u32)?;
ioctl_u32(&tablet.file, UI_SET_EVBIT, EV_SYN as u32)?;
tablet.keybit(BTN_TOOL_PEN)?;
tablet.absbit(ABS_X, 65535)?;
tablet.absbit(ABS_Y, 65535)?;
tablet.finish()?;
// Stay in proximity so hover motion keeps updating the cursor.
tablet.emit(EV_KEY, BTN_TOOL_PEN, 1)?;
tablet.syn()?;
Ok(Self {
keyboard,
pointer,
tablet,
})
}
}
pub struct UinputBackend {
devices: Devices,
held_keys: HashSet<u16>,
held_buttons: HashSet<u16>,
}
impl UinputBackend {
pub fn connect() -> Result<Self> {
let devices = Devices::create()?;
Ok(Self {
devices,
held_keys: HashSet::new(),
held_buttons: HashSet::new(),
})
}
}
impl InputBackend for UinputBackend {
fn name(&self) -> &'static str {
"uinput"
}
fn key(&mut self, vkey: u16, down: bool) -> Result<()> {
let code = vk_to_linux_key(vkey);
if code == 0 {
return Ok(()); // not representable on this layout; drop quietly
}
let value = if down { 1 } else { 0 };
self.devices.keyboard.emit(EV_KEY, code, value)?;
self.devices.keyboard.syn()?;
if down {
self.held_keys.insert(code);
} else {
self.held_keys.remove(&code);
}
Ok(())
}
fn button(&mut self, button: u16, down: bool) -> Result<()> {
let code = match button {
1 => BTN_LEFT,
2 => BTN_RIGHT,
3 => BTN_MIDDLE,
8 => BTN_SIDE,
9 => BTN_EXTRA,
_ => return Ok(()), // unknown buttons are dropped, not fatal
};
let value = if down { 1 } else { 0 };
self.devices.pointer.emit(EV_KEY, code, value)?;
self.devices.pointer.syn()?;
if down {
self.held_buttons.insert(code);
} else {
self.held_buttons.remove(&code);
}
Ok(())
}
fn motion(&mut self, absolute: bool, x: i32, y: i32) -> Result<()> {
if absolute {
self.devices.tablet.emit(EV_ABS, ABS_X, x.clamp(0, 65535))?;
self.devices.tablet.emit(EV_ABS, ABS_Y, y.clamp(0, 65535))?;
self.devices.tablet.syn()?;
} else {
self.devices.pointer.emit(EV_REL, REL_X, x)?;
self.devices.pointer.emit(EV_REL, REL_Y, y)?;
self.devices.pointer.syn()?;
}
Ok(())
}
fn wheel(&mut self, horizontal: bool, delta: i32) -> Result<()> {
self.devices.pointer.emit(
EV_REL,
if horizontal { REL_HWHEEL } else { REL_WHEEL },
super::wheel_steps(delta),
)?;
self.devices.pointer.syn()
}
fn release_all(&mut self) -> Result<()> {
for code in self.held_keys.clone() {
self.devices.keyboard.emit(EV_KEY, code, 0)?;
}
self.held_keys.clear();
for code in self.held_buttons.clone() {
self.devices.pointer.emit(EV_KEY, code, 0)?;
}
self.held_buttons.clear();
self.devices.keyboard.syn()?;
self.devices.pointer.syn()
}
}
/// Windows virtual-key code -> Linux input keycode, invariant subset.
/// The layout-aware remainder arrives with the Phase 2 semantic text path.
pub(crate) fn vk_to_linux_key(vkey: u16) -> u16 {
let base = vkey & 0xff;
let extended = vkey & 0x100 != 0;
let code = match base {
0x08 => linux::KEY_BACKSPACE,
0x09 => linux::KEY_TAB,
0x0d if extended => linux::KEY_KPENTER,
0x0d => linux::KEY_ENTER,
0x10 | 0xa0 => linux::KEY_LEFTSHIFT,
0xa1 => linux::KEY_RIGHTSHIFT,
0x11 | 0xa2 if extended => linux::KEY_RIGHTCTRL,
0x11 | 0xa2 => linux::KEY_LEFTCTRL,
0xa3 => linux::KEY_RIGHTCTRL,
0x12 | 0xa4 if extended => linux::KEY_RIGHTALT,
0x12 | 0xa4 => linux::KEY_LEFTALT,
0xa5 => linux::KEY_RIGHTALT,
0x13 => linux::KEY_PAUSE,
0x14 => linux::KEY_CAPSLOCK,
0x1b => linux::KEY_ESC,
0x20 => linux::KEY_SPACE,
0x21 => linux::KEY_PAGEUP,
0x22 => linux::KEY_PAGEDOWN,
0x23 => linux::KEY_END,
0x24 => linux::KEY_HOME,
0x25 => linux::KEY_LEFT,
0x26 => linux::KEY_UP,
0x27 => linux::KEY_RIGHT,
0x28 => linux::KEY_DOWN,
0x2d => linux::KEY_INSERT,
0x2e => linux::KEY_DELETE,
0x30 => linux::KEY_0,
0x31 => linux::KEY_1,
0x32 => linux::KEY_2,
0x33 => linux::KEY_3,
0x34 => linux::KEY_4,
0x35 => linux::KEY_5,
0x36 => linux::KEY_6,
0x37 => linux::KEY_7,
0x38 => linux::KEY_8,
0x39 => linux::KEY_9,
0x41 => linux::KEY_A,
0x42 => linux::KEY_B,
0x43 => linux::KEY_C,
0x44 => linux::KEY_D,
0x45 => linux::KEY_E,
0x46 => linux::KEY_F,
0x47 => linux::KEY_G,
0x48 => linux::KEY_H,
0x49 => linux::KEY_I,
0x4a => linux::KEY_J,
0x4b => linux::KEY_K,
0x4c => linux::KEY_L,
0x4d => linux::KEY_M,
0x4e => linux::KEY_N,
0x4f => linux::KEY_O,
0x50 => linux::KEY_P,
0x51 => linux::KEY_Q,
0x52 => linux::KEY_R,
0x53 => linux::KEY_S,
0x54 => linux::KEY_T,
0x55 => linux::KEY_U,
0x56 => linux::KEY_V,
0x57 => linux::KEY_W,
0x58 => linux::KEY_X,
0x59 => linux::KEY_Y,
0x5a => linux::KEY_Z,
0x5b => linux::KEY_LEFTMETA,
0x5c => linux::KEY_RIGHTMETA,
0x60 => linux::KEY_KP0,
0x61 => linux::KEY_KP1,
0x62 => linux::KEY_KP2,
0x63 => linux::KEY_KP3,
0x64 => linux::KEY_KP4,
0x65 => linux::KEY_KP5,
0x66 => linux::KEY_KP6,
0x67 => linux::KEY_KP7,
0x68 => linux::KEY_KP8,
0x69 => linux::KEY_KP9,
0x6a => linux::KEY_KPASTERISK,
0x6b => linux::KEY_KPPLUS,
0x6d => linux::KEY_KPMINUS,
0x6e => linux::KEY_KPDOT,
0x6f => linux::KEY_KPSLASH,
0x70 => linux::KEY_F1,
0x71 => linux::KEY_F2,
0x72 => linux::KEY_F3,
0x73 => linux::KEY_F4,
0x74 => linux::KEY_F5,
0x75 => linux::KEY_F6,
0x76 => linux::KEY_F7,
0x77 => linux::KEY_F8,
0x78 => linux::KEY_F9,
0x79 => linux::KEY_F10,
0x7a => linux::KEY_F11,
0x7b => linux::KEY_F12,
0xba => linux::KEY_SEMICOLON,
0xbb => linux::KEY_EQUAL,
0xbc => linux::KEY_COMMA,
0xbd => linux::KEY_MINUS,
0xbe => linux::KEY_DOT,
0xbf => linux::KEY_SLASH,
0xc0 => linux::KEY_GRAVE,
0xdb => linux::KEY_LEFTBRACE,
0xdc => linux::KEY_BACKSLASH,
0xdd => linux::KEY_RIGHTBRACE,
0xde => linux::KEY_APOSTROPHE,
_ => return 0,
};
code as u16
}
#[cfg(test)]
mod tests {
use super::vk_to_linux_key;
use input_linux_sys as linux;
#[test]
fn qwerty_row_uses_evdev_physical_positions() {
let mapped: Vec<u16> = "QWERTYUIOP"
.bytes()
.map(|key| vk_to_linux_key(key.into()))
.collect();
assert_eq!(
mapped,
[
linux::KEY_Q,
linux::KEY_W,
linux::KEY_E,
linux::KEY_R,
linux::KEY_T,
linux::KEY_Y,
linux::KEY_U,
linux::KEY_I,
linux::KEY_O,
linux::KEY_P,
]
.map(|code| code as u16)
);
}
#[test]
fn alphabet_is_not_assumed_contiguous() {
let mapped: Vec<u16> = "ABCDEFGHIJKLMNOPQRSTUVWXYZ"
.bytes()
.map(|key| vk_to_linux_key(key.into()))
.collect();
assert_eq!(
mapped,
[
linux::KEY_A,
linux::KEY_B,
linux::KEY_C,
linux::KEY_D,
linux::KEY_E,
linux::KEY_F,
linux::KEY_G,
linux::KEY_H,
linux::KEY_I,
linux::KEY_J,
linux::KEY_K,
linux::KEY_L,
linux::KEY_M,
linux::KEY_N,
linux::KEY_O,
linux::KEY_P,
linux::KEY_Q,
linux::KEY_R,
linux::KEY_S,
linux::KEY_T,
linux::KEY_U,
linux::KEY_V,
linux::KEY_W,
linux::KEY_X,
linux::KEY_Y,
linux::KEY_Z,
]
.map(|code| code as u16)
);
}
#[test]
fn non_contiguous_function_keys_and_extended_modifiers_are_preserved() {
assert_eq!(vk_to_linux_key(0x7a), linux::KEY_F11 as u16);
assert_eq!(vk_to_linux_key(0x7b), linux::KEY_F12 as u16);
assert_eq!(vk_to_linux_key(0x111), linux::KEY_RIGHTCTRL as u16);
assert_eq!(vk_to_linux_key(0x112), linux::KEY_RIGHTALT as u16);
assert_eq!(vk_to_linux_key(0x10d), linux::KEY_KPENTER as u16);
}
}