fix: refined swhks ipc.rs for hash calculation and finding buffer byte (#306)

* fix: unblock all rfkill softblocks to avoid radio devs turning off

This commit attempts at fixing the major issue of rfkill not being
properly turned off while creating the swhkd virtual device.

Changes made:

1. Added RfkillEvent struct that stores the rfkill details and status
required with documentation
2. Added two new macros with `ioctl_readwrite` to ensure that we can
query the rfkill status and modify properly
3. New function `unblock_rfkill` that unblocks all soft blocks for any
device
4. Called `unblock_rfkill` function in `create_uinput_switches_device`
that ensures that rfkill is NOT blocked and complies with rfkill-input
being disabled

This should ensure that rfkill does not react when virtual device is
being created.

* fix: clean up code in swhks ipc.rs

1. Calculate hash function now borrows the string instead of taking
ownership
2. Used match to check for buffer byte instead of if statement
3. Added more debug logging and error handling

* chore: fallback commit to parent ca82393

Remove updated logic for uinput.rs as it does not work

* fix: use is_some_and instead of map_for in daemon.rs

replaced `map_for` with `is_some_and` as it is more efficient in this
case (simple bool ops)

Author: nots1dd

swhkd/src/daemon.rs

@@ -543,7 +543,7 @@ async fn main() -> Result<(), Box<dyn Error>> {
 }
 
 pub fn check_device_is_keyboard(device: &Device) -> bool {
-    if device.supported_keys().map_or(false, |keys| keys.contains(Key::KEY_ENTER)) {
+    if device.supported_keys().is_some_and(|keys| keys.contains(Key::KEY_ENTER)) {
         if device.name() == Some("swhkd virtual output") {
             return false;
         }

swhks/src/ipc.rs

@@ -17,14 +17,14 @@ fn get_env() -> Result<String, Box<dyn std::error::Error>> {
 /// Calculates a simple hash of the string
 /// Uses the DefaultHasher from the std::hash module which is not a cryptographically secure hash,
 /// however, it is good enough for our use case.
-pub fn calculate_hash(t: String) -> u64 {
+pub fn calculate_hash(t: &str) -> u64 {
     let mut hasher = DefaultHasher::new();
     t.hash(&mut hasher);
     hasher.finish()
 }
 
 pub fn server_loop(sock_file_path: &str) -> std::io::Result<()> {
-    let mut prev_hash = calculate_hash(String::new());
+    let mut prev_hash = calculate_hash("");
 
     let listener = UnixListener::bind(sock_file_path)?;
     // Init a buffer to read the incoming message
@@ -34,36 +34,60 @@ pub fn server_loop(sock_file_path: &str) -> std::io::Result<()> {
     for stream in listener.incoming() {
         match stream {
             Ok(mut stream) => {
-                stream.read_exact(&mut buff)?;
-                // If the buffer is [1] then it is a VERIFY message
-                // the hash of the environment variables is sent back to the client
-                // then the stream is flushed and the loop continues
-                if buff == [1] {
-                    log::debug!("Received VERIFY message from swhkd");
-                    let _ = stream.write_all(prev_hash.to_string().as_bytes());
-                    log::debug!("Sent hash to swhkd");
-                    stream.flush()?;
+                if let Err(e) = stream.read_exact(&mut buff) {
+                    log::error!("Failed to read from stream: {}", e);
                     continue;
                 }
-                // If the buffer is [2] then it is a GET message
-                // the environment variables are sent back to the client
-                // then the stream is flushed and the loop continues
-                if buff == [2] {
-                    log::debug!("Received GET message from swhkd");
-                    let env = get_env().unwrap();
-                    if prev_hash == calculate_hash(env.clone()) {
-                        log::debug!("No changes in environment variables");
-                    } else {
-                        log::debug!("Changes in environment variables");
+
+                match buff[0] {
+                    1 => {
+                        // If the buffer is [1] then it is a VERIFY message
+                        // the hash of the environment variables is sent back to the client
+                        // then the stream is flushed and the loop continues
+                        log::debug!("Received VERIFY request from swhkd");
+                        if let Err(e) = stream.write_all(prev_hash.to_string().as_bytes()) {
+                            log::error!("Failed to write hash to stream: {}", e);
+                        } else {
+                            log::debug!("Sent hash to swhkd");
+                        }
                     }
-                    prev_hash = calculate_hash(env.clone());
-                    let _ = stream.write_all(env.as_bytes());
-                    stream.flush()?;
-                    continue;
+                    2 => {
+                        // If the buffer is [2] then it is a GET message
+                        // the environment variables are sent back to the client
+                        // then the stream is flushed and the loop continues
+                        log::debug!("Received GET request from swhkd");
+
+                        match get_env() {
+                            Ok(env) => {
+                                let new_hash = calculate_hash(&env);
+                                if prev_hash == new_hash {
+                                    log::debug!("No changes in environment variables");
+                                } else {
+                                    log::debug!("Environment variables updated");
+                                    prev_hash = new_hash;
+                                }
+
+                                if let Err(e) = stream.write_all(env.as_bytes()) {
+                                    log::error!("Failed to send environment variables: {}", e);
+                                }
+                            }
+                            Err(e) => {
+                                log::error!("Failed to retrieve environment variables: {}", e);
+                                let _ = stream.write_all(b"ERROR: Unable to fetch environment");
+                            }
+                        }
+                    }
+                    _ => {
+                        log::warn!("Received unknown request: {}", buff[0]);
+                    }
+                }
+
+                if let Err(e) = stream.flush() {
+                    log::error!("Failed to flush stream: {}", e);
                 }
             }
             Err(e) => {
-                log::error!("Error: {}", e);
+                log::error!("Error handling connection: {}", e);
                 break;
             }
         }