From d7806619ec6c9b6259714f835a9e03ac422b6a16 Mon Sep 17 00:00:00 2001 From: Lennard Kittner Date: Thu, 12 Mar 2026 10:20:01 +0100 Subject: [PATCH] Draft creating udev rules automatically --- Cargo.lock | 18 ++++++ Cargo.toml | 2 + src/bin/hyper_headset_cli.rs | 115 ++++++++++++++++++++++++++++++++++- 3 files changed, 133 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 7b0720b..c0ebe7c 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -359,7 +359,9 @@ dependencies = [ "enigo", "hidapi", "ksni", + "shell-escape", "thistermination", + "users", ] [[package]] @@ -551,6 +553,12 @@ dependencies = [ "windows-sys 0.61.2", ] +[[package]] +name = "shell-escape" +version = "0.1.5" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "45bb67a18fa91266cc7807181f62f9178a6873bfad7dc788c42e6430db40184f" + [[package]] name = "shlex" version = "1.3.0" @@ -633,6 +641,16 @@ version = "0.1.14" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "7dd6e30e90baa6f72411720665d41d89b9a3d039dc45b8faea1ddd07f617f6af" +[[package]] +name = "users" +version = "0.11.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24cc0f6d6f267b73e5a2cadf007ba8f9bc39c6a6f9666f8cf25ea809a153b032" +dependencies = [ + "libc", + "log", +] + [[package]] name = "utf8parse" version = "0.2.2" diff --git a/Cargo.toml b/Cargo.toml index 6dcfc8d..4c6f96a 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -12,3 +12,5 @@ hidapi = { path = "vendor/hidapi" } thistermination = "1.0.0" [target.'cfg(target_os = "linux")'.dependencies] ksni = "0.2.0" +users = "0.11" +shell-escape = "0.1.5" diff --git a/src/bin/hyper_headset_cli.rs b/src/bin/hyper_headset_cli.rs index e7dfe9f..3cd8af1 100644 --- a/src/bin/hyper_headset_cli.rs +++ b/src/bin/hyper_headset_cli.rs @@ -1,11 +1,122 @@ -use std::time::Duration; +use std::{ + fs, + io::{self}, + time::Duration, +}; use clap::{Arg, Command}; -use hyper_headset::devices::connect_compatible_device; +use hyper_headset::{debug_println, devices::connect_compatible_device}; +use std::process::Command as CommandShell; const SHOW_ALL_OPTIONS: bool = false; +const UDEV_RULE_PATH_SYSTEM: &str = "/etc/udev/rules.d/99-HyperHeadset.rules"; +const UDEV_RULE_PATH_USER: &str = "/usr/lib/udev/rules.d/99-HyperHeadset.rules"; +const UDEV_RULES: &str = include_str!("./../../99-HyperHeadset.rules"); + +#[derive(Debug)] +pub enum RuleState { + RuleExists(bool), + RuleMatch(bool), +} + +pub fn check_rule(path: &str, rules: &str) -> RuleState { + let mut rule_state; + + if !fs::exists(path).unwrap_or(false) { + rule_state = RuleState::RuleExists(false); + } else { + rule_state = RuleState::RuleExists(true); + if let Ok(content) = fs::read_to_string(path) { + if content.trim() != rules.trim() { + rule_state = RuleState::RuleMatch(false); + } else { + rule_state = RuleState::RuleMatch(true); + } + } + } + rule_state +} + +pub fn update_rule(path: &str, rules: &str) { + let status = CommandShell::new("sudo") + .arg("sh") + .arg("-c") + .arg(format!( + "echo {} > {}", + shell_escape::escape(rules.into()), + path + )) + .status(); + + match status { + Ok(exit_status) if exit_status.success() => { + println!("created rule at {path}.\nYou may need to replug your headset for the udev rules to take effect."); + } + Ok(e) => { + println!("Failed to create rule at {path}: {}", e); + println!("Your headset may not be recognized without the correct udev rules."); + } + Err(e) => { + println!("Failed to create rule at {path}: {}", e); + println!("Your headset may not be recognized without the correct udev rules."); + } + } +} + fn main() { + let user_rule_state = check_rule(UDEV_RULE_PATH_USER, UDEV_RULES); + let system_rule_state = check_rule(UDEV_RULE_PATH_SYSTEM, UDEV_RULES); + + if users::get_current_uid() != 0 { + debug_println!("user rule: {user_rule_state:?}, system rule: {system_rule_state:?}"); + match (user_rule_state, system_rule_state) { + (RuleState::RuleMatch(true), _) => (), + (_, RuleState::RuleMatch(true)) => (), + + (RuleState::RuleMatch(false), _) | (RuleState::RuleExists(true), _) => { + print!( + "Udev rules at {UDEV_RULE_PATH_USER} do not have the expected value. Do you want to recreate them? (y/N): " + ); + io::Write::flush(&mut io::stdout()).unwrap(); + let mut input = String::new(); + io::stdin().read_line(&mut input).unwrap(); + if matches!(input.trim(), "y" | "Y") { + update_rule(UDEV_RULE_PATH_USER, UDEV_RULES); + } else { + println!("Your headset may not be recognized without the correct udev rules."); + } + } + (RuleState::RuleExists(false), RuleState::RuleMatch(false)) + | (RuleState::RuleExists(false), RuleState::RuleExists(true)) => { + print!( + "Udev rules at {UDEV_RULE_PATH_SYSTEM} do not have the expected value. Do you want to recreate them? (y/N): " + ); + io::Write::flush(&mut io::stdout()).unwrap(); + let mut input = String::new(); + io::stdin().read_line(&mut input).unwrap(); + if matches!(input.trim(), "y" | "Y") { + update_rule(UDEV_RULE_PATH_SYSTEM, UDEV_RULES); + } else { + println!("Your headset may not be recognized without the correct udev rules."); + } + } + + (RuleState::RuleExists(false), RuleState::RuleExists(false)) => { + print!("No udev rules found. Do you want to create {UDEV_RULE_PATH_USER}? (y/N): "); + io::Write::flush(&mut io::stdout()).unwrap(); + let mut input = String::new(); + io::stdin().read_line(&mut input).unwrap(); + if matches!(input.trim(), "y" | "Y") { + update_rule(UDEV_RULE_PATH_USER, UDEV_RULES); + } else { + println!( + "Without udev rules your headset can only be accessed when running as root." + ); + } + } + } + } let mut device = match connect_compatible_device() { Ok(device) => device, Err(error) => {