`ca44876`

fix: prevent deviceless machines from initiating transfers

Add has_devices flag to EvdevGrabber that tracks whether the machine
has physical input devices. Machines without devices (e.g. headless
servers or remote desktops) can still receive control transfers but
cannot initiate them, since they have no input to capture and forward.

This fixes a deadlock where a deviceless machine would try to initiate
a transfer, enter RemoteActive state with no evdev thread to capture
input, while the peer would wait forever in ReceivedControl for input
that never arrives.

Authored by mfwolffe <wolffemf@dukes.jmu.edu> 4 months ago

SHA: ca44876ddfd05184dff035359d920e0ca88ee10d
Parents: 1e3d833
Tree: c4fb389

2 changed files

Status	File	+	-
M	`hyprkvm-daemon/src/input/evdev_grab.rs`	20	2
M	`hyprkvm-daemon/src/main.rs`	47	18

hyprkvm-daemon/src/input/evdev_grab.rsmodified

      recovery_active: Arc<AtomicU64>,
      /// The direction to watch for in recovery mode (encoded as u8: 1=Up, 2=Down, 3=Left, 4=Right, 0=none)
      recovery_direction: Arc<AtomicU64>,
++    /// Flag indicating whether this grabber has input devices to grab
++    /// If false, this machine cannot initiate transfers (but can still receive them)
++    has_devices: Arc<AtomicBool>,
      event_rx: mpsc::Receiver<GrabEvent>,
      _thread: thread::JoinHandle<()>,
  }
          let recovery_clone = recovery_active.clone();
          let recovery_direction = Arc::new(AtomicU64::new(0));
          let recovery_dir_clone = recovery_direction.clone();
++        let has_devices = Arc::new(AtomicBool::new(false));
++        let has_devices_clone = has_devices.clone();
          let (event_tx, event_rx) = mpsc::channel();
          let thread = thread::Builder::new()
              .name("evdev-grabber".to_string())
              .spawn(move || {
--                if let Err(e) = run_evdev_grabber(active_clone, recovery_clone, recovery_dir_clone, event_tx) {
++                if let Err(e) = run_evdev_grabber(active_clone, recovery_clone, recovery_dir_clone, has_devices_clone, event_tx) {
                      tracing::error!("Evdev grabber error: {}", e);
                  }
              })
              active,
              recovery_active,
              recovery_direction,
++            has_devices,
              event_rx,
              _thread: thread,
          })
          self.active.load(Ordering::SeqCst)
      }
++    /// Check if this grabber has input devices available
++    /// If false, this machine cannot initiate transfers (no devices to grab)
++    /// but can still receive control from other machines
++    pub fn has_devices(&self) -> bool {
++        self.has_devices.load(Ordering::SeqCst)
++    }
++
      /// Try to receive a grab event (non-blocking)
      pub fn try_recv(&self) -> Option<GrabEvent> {
          self.event_rx.try_recv().ok()
      active: Arc<AtomicBool>,
      recovery_active: Arc<AtomicU64>,
      recovery_direction: Arc<AtomicU64>,
++    has_devices: Arc<AtomicBool>,
      event_tx: mpsc::Sender<GrabEvent>,
  ) -> Result<(), EvdevGrabError> {
      let device_paths = find_input_devices();
      if device_paths.is_empty() {
++        tracing::warn!("No input devices found - this machine cannot initiate transfers");
++        // Leave has_devices as false (default)
          return Err(EvdevGrabError::NoDevices);
      }
--    tracing::info!("Found {} input device paths", device_paths.len());
++    // Mark that we have devices - transfers can be initiated from this machine
++    has_devices.store(true, Ordering::SeqCst);
++    tracing::info!("Found {} input device paths (can initiate transfers)", device_paths.len());
      for path in &device_paths {
          tracing::debug!("  {}", path.display());
      }

hyprkvm-daemon/src/main.rsmodified

                                  if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) {
                                      info!("RECOVERY HOTKEY: Barrier enabled, blocking transfer");
++                                } else if !input_grabber.has_devices() {
++                                    // Should never happen (no devices = no recovery hotkey events)
++                                    // but guard against it anyway
++                                    tracing::debug!("RECOVERY HOTKEY: No input devices, cannot initiate");
                                  } else {
                                      info!("RECOVERY HOTKEY: At edge with peer, initiating transfer to {:?}", direction);
                                      if let Err(e) = transfer_manager.initiate_transfer(
                                  cursor_pos.0,
                                  cursor_pos.1
                              );
++                        } else if !input_grabber.has_devices() {
++                            // No input devices = cannot initiate transfers (deviceless machine)
++                            tracing::debug!(
++                                "EDGE: {:?} at ({}, {}) - no input devices, cannot initiate",
++                                direction,
++                                cursor_pos.0,
++                                cursor_pos.1
++                            );
                          } else {
                              info!(
                                  "EDGE: {:?} at ({}, {}) - initiating transfer",
                                                              "CURSOR EDGE: {:?} at ({}, {}) - barrier enabled, blocking",
                                                              edge_dir, cx, cy
                                                          );
++                                                    } else if !input_grabber.has_devices() {
++                                                        // No input devices = cannot initiate transfers
++                                                        tracing::debug!(
++                                                            "CURSOR EDGE: {:?} at ({}, {}) - no input devices, cannot initiate",
++                                                            edge_dir, cx, cy
++                                                        );
                                                      } else {
                                                          info!(
                                                              "CURSOR EDGE: {:?} at ({}, {}) - initiating transfer",
                                      // At edge with peer but received control from different direction
                                      if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) {
                                          IpcResponse::Error { message: "Barrier enabled".to_string() }
++                                    } else if !input_grabber.has_devices() {
++                                        IpcResponse::Error { message: "No input devices - cannot initiate transfer".to_string() }
                                      } else {
                                          // Initiate new transfer
                                          let cursor_pos = hypr_client.cursor_pos().await
+                                     }
                                  } else if barrier_enabled.load(std::sync::atomic::Ordering::SeqCst) {
                                      IpcResponse::Error { message: "Barrier enabled".to_string() }
++                                } else if !input_grabber.has_devices() {
++                                    IpcResponse::Error { message: "No input devices - cannot initiate transfer".to_string() }
                                  } else {
                                      // Initiate new transfer
                                      let cursor_pos = hypr_client.cursor_pos().await
                                  if peers_guard.get(&dir).is_some() {
                                      drop(peers_guard);
--                                    // Get cursor position (use center of total screen)
++                                    // Check if we have input devices before initiating
--                                    let cursor_pos = hypr_client.cursor_pos().await
++                                    if !input_grabber.has_devices() {
--                                        .map(|c| (c.x, c.y))
++                                        IpcResponse::Error {
--                                        .unwrap_or(((screen_min_x + screen_max_x) / 2, (screen_min_y + screen_max_y) / 2));
++                                            message: "No input devices - cannot initiate transfer".to_string(),
--
--                                    // Initiate transfer (CLI-initiated, not keyboard)
--                                    info!("IPC Switch: calling initiate_transfer");
--                                    match transfer_manager.initiate_transfer(dir, cursor_pos, screen_min_x, screen_min_y, screen_max_x, screen_max_y, false).await {
--                                        Ok(()) => {
--                                            let machine_name = config.machines.neighbors
--                                                .iter()
--                                                .find(|n| n.direction == dir)
--                                                .map(|n| n.name.clone())
--                                                .unwrap_or_else(|| format!("{:?}", dir));
--                                            info!("IPC Switch: initiate_transfer succeeded, returning response to CLI");
--                                            IpcResponse::Transferred { to_machine: machine_name }
+                                         }
--                                        Err(e) => IpcResponse::Error {
++                                    } else {
--                                            message: format!("Transfer failed: {}", e),
++                                        // Get cursor position (use center of total screen)
++                                        let cursor_pos = hypr_client.cursor_pos().await
++                                            .map(|c| (c.x, c.y))
++                                            .unwrap_or(((screen_min_x + screen_max_x) / 2, (screen_min_y + screen_max_y) / 2));
++
++                                        // Initiate transfer (CLI-initiated, not keyboard)
++                                        info!("IPC Switch: calling initiate_transfer");
++                                        match transfer_manager.initiate_transfer(dir, cursor_pos, screen_min_x, screen_min_y, screen_max_x, screen_max_y, false).await {
++                                            Ok(()) => {
++                                                let machine_name = config.machines.neighbors
++                                                    .iter()
++                                                    .find(|n| n.direction == dir)
++                                                    .map(|n| n.name.clone())
++                                                    .unwrap_or_else(|| format!("{:?}", dir));
++                                                info!("IPC Switch: initiate_transfer succeeded, returning response to CLI");
++                                                IpcResponse::Transferred { to_machine: machine_name }
++                                            }
++                                            Err(e) => IpcResponse::Error {
++                                                message: format!("Transfer failed: {}", e),
++                                            }
+                                         }
+                                     }
                                  } else {