`de34ada`

fix: use XComposite overlay window for compositor compatibility

Authored by

espadonne 3 months ago

SHA: de34adab58218962f467a0ab939f9bd295fbcea0
Parents: 86e45ae
Tree: 13958e5

5 changed files

Status	File	+	-
M	`Cargo.lock`	1	1
M	`Cargo.toml`	1	1
M	`garlock/src/main.rs`	60	12
M	`garlock/src/screenshot.rs`	32	0
M	`garlock/src/x11/window.rs`	126	4

Cargo.lockmodified

  [[package]]
  name = "garlock"
 -version = "0.2.0"
 +version = "0.3.0"
  dependencies = [
   "anyhow",
   "cairo-rs",

Cargo.tomlmodified

  [workspace.dependencies]
  # X11
 -x11rb = { version = "0.13", features = ["allow-unsafe-code", "randr"] }
 +x11rb = { version = "0.13", features = ["allow-unsafe-code", "randr", "composite"] }
  # Graphics
  cairo-rs = { version = "0.18", features = ["png"] }

garlock/src/main.rsmodified

  use std::path::PathBuf;
  use tracing_subscriber::{layer::SubscriberExt, util::SubscriberInitExt, EnvFilter};
  use x11rb::connection::Connection;
 +use x11rb::wrapper::ConnectionExt as WrapperConnectionExt;
  mod auth;
  mod background;
      tracing::info!("Capturing screenshot...");
      let mut background = match Screenshot::capture() {
          Ok(screenshot) => {
 -            tracing::debug!(
 +            tracing::info!(
                  width = screenshot.width,
                  height = screenshot.height,
 -                "Screenshot captured, applying blur"
 +                depth = screenshot.depth,
 +                data_len = screenshot.data.len(),
 +                "Screenshot captured successfully"
              );
              // Process with blur and brightness from config
                  config.background.blur_radius,
                  config.background.brightness,
              ) {
 -                Ok(bg) => bg,
 +                Ok(bg) => {
 +                    tracing::info!(
 +                        bg_width = bg.width,
 +                        bg_height = bg.height,
 +                        bg_data_len = bg.data.len(),
 +                        "Background processed successfully"
 +                    );
 +                    bg
 +                }
                  Err(e) => {
 -                    tracing::warn!("Failed to process screenshot: {}, using fallback", e);
 +                    tracing::error!("Failed to process screenshot: {}, using fallback", e);
                      let (conn, screen_num) = x11rb::connect(None)?;
                      let screen = &conn.setup().roots[screen_num];
                      Background::solid_color(
+             }
+         }
          Err(e) => {
 -            tracing::warn!("Failed to capture screenshot: {}, using fallback", e);
 +            tracing::error!("Failed to capture screenshot: {}, using fallback", e);
              let (conn, screen_num) = x11rb::connect(None)?;
              let screen = &conn.setup().roots[screen_num];
              Background::solid_color(
+         }
      };
 +    // Step 2: Create fullscreen locker window with input grabs
 +    tracing::info!("Creating locker window...");
 +    let locker = LockerWindow::new()?;
++
 +    // Check for size mismatch between background and window
 +    let win_width = locker.width() as u32;
 +    let win_height = locker.height() as u32;
 +    let win_depth = locker.depth();
++
 +    tracing::info!(
 +        win_width,
 +        win_height,
 +        win_depth,
 +        bg_width = background.width,
 +        bg_height = background.height,
 +        "Window created, checking dimensions"
 +    );
++
 +    // Resize background if dimensions don't match
 +    if background.width != win_width || background.height != win_height {
 +        tracing::warn!(
 +            "Size mismatch! Background {}x{} vs Window {}x{}. Using solid fallback.",
 +            background.width,
 +            background.height,
 +            win_width,
 +            win_height
 +        );
 +        background = Background::solid_color(win_width, win_height, &config.background.fallback_color);
 +    }
++
      // Keep a clean copy of the background for re-compositing
      let background_clean = background.data.clone();
      let bg_width = background.width;
      let bg_height = background.height;
 -    // Step 2: Create fullscreen locker window with input grabs
 -    tracing::info!("Creating locker window...");
 -    let locker = LockerWindow::new()?;
+-
      // Step 3: Initialize keyboard handler with XKB
      tracing::info!("Initializing keyboard handler...");
      let mut keyboard = Keyboard::new()?;
          Ok(())
      };
 -    // Initial render
 -    render_frame(
 +    // Initial render - CRITICAL: must complete before event loop
 +    tracing::info!("Performing initial render...");
 +    match render_frame(
          &mut background,
          &background_clean,
          &ring,
          keyboard.caps_lock_active(),
          locker_state.failed_attempts,
          locker_state.cooldown_remaining(),
 -    )?;
 +    ) {
 +        Ok(()) => tracing::info!("Initial render completed successfully"),
 +        Err(e) => {
 +            tracing::error!("Initial render failed: {}", e);
 +            return Err(e);
 +        }
 +    }
++
 +    // Sync to ensure the image is displayed before continuing
 +    locker.conn().sync()?;
 +    tracing::debug!("X11 sync completed");
      // Get current username for PAM authentication
      let username = get_current_username()?;

garlock/src/screenshot.rsmodified

              );
+         }
 +        // Check if screenshot is mostly black (compositor might not be exposing root window)
 +        let non_black_pixels = Self::count_non_black_pixels(&reply.data);
 +        let total_pixels = (width as usize * height as usize) as f64;
 +        let non_black_ratio = non_black_pixels as f64 / total_pixels;
++
 +        if non_black_ratio < 0.01 {
 +            tracing::warn!(
 +                "Screenshot appears to be mostly black ({:.2}% non-black pixels). \
 +                 This may indicate compositor is not exposing root window contents.",
 +                non_black_ratio * 100.0
 +            );
 +        } else {
 +            tracing::debug!(
 +                "Screenshot content check: {:.1}% non-black pixels",
 +                non_black_ratio * 100.0
 +            );
 +        }
++
          Ok(Self {
              data: reply.data,
              width: width as u32,
          bgra_to_rgba(&mut rgba);
          rgba
+     }
++
 +    /// Count pixels that are not pure black (for detecting empty screenshots)
 +    fn count_non_black_pixels(data: &[u8]) -> usize {
 +        let mut count = 0;
 +        // Sample every 100th pixel for performance
 +        for chunk in data.chunks_exact(4).step_by(100) {
 +            // BGRA format - check if any color channel is non-zero
 +            if chunk[0] > 5 || chunk[1] > 5 || chunk[2] > 5 {
 +                count += 1;
 +            }
 +        }
 +        // Extrapolate to total
 +        count * 100
 +    }
+ }
  /// Convert BGRA pixel data to RGBA in-place

garlock/src/x11/window.rsmodified

  //!
  //! Creates an override-redirect window that covers all monitors
  //! and grabs keyboard/pointer to prevent escape.
 +//!
 +//! With compositors, uses the XComposite overlay window to ensure
 +//! the lock screen is rendered above the compositor's output.
  use anyhow::{Context, Result};
  use std::time::Duration;
  use x11rb::connection::Connection;
 +use x11rb::protocol::composite::{self, ConnectionExt as CompositeConnectionExt};
  use x11rb::protocol::xproto::*;
  use x11rb::rust_connection::RustConnection;
  use x11rb::wrapper::ConnectionExt as WrapperConnectionExt;
      width: u16,
      height: u16,
      depth: u8,
 +    /// Overlay window from XComposite (if available)
 +    overlay_window: Option<Window>,
+ }
  impl LockerWindow {
      /// Create a new fullscreen locker window
      ///
      /// This will:
 -    /// 1. Create an override-redirect fullscreen window
 -    /// 2. Grab the keyboard (retrying until successful)
 -    /// 3. Grab the pointer
 +    /// 1. Try to get the XComposite overlay window (for compositor compatibility)
 +    /// 2. Create an override-redirect fullscreen window
 +    /// 3. Grab the keyboard (retrying until successful)
 +    /// 4. Grab the pointer
      pub fn new() -> Result<Self> {
          let (conn, screen_num) =
              x11rb::connect(None).context("Failed to connect to X server")?;
          tracing::info!(width, height, "Connected to X server");
 +        // Try to get the XComposite overlay window for compositor compatibility
 +        let overlay_window = Self::get_overlay_window(&conn, root);
++
 +        // Determine parent window - use overlay if available, otherwise root
 +        let parent = overlay_window.unwrap_or(root);
 +        if overlay_window.is_some() {
 +            tracing::info!("Using XComposite overlay window for compositor compatibility");
 +        } else {
 +            tracing::debug!("XComposite overlay not available, using root window");
 +        }
++
          // Create fullscreen window
          let window = conn.generate_id().context("Failed to generate window ID")?;
          conn.create_window(
              depth,
              window,
 -            root,
 +            parent,
 ,
 ,
              width,
          conn.map_window(window).context("Failed to map window")?;
          conn.flush().context("Failed to flush after map")?;
 +        // Wait for MapNotify to ensure window is visible before rendering
 +        tracing::debug!("Waiting for window to be mapped...");
 +        let start = std::time::Instant::now();
 +        let timeout = Duration::from_secs(2);
 +        let mut mapped = false;
++
 +        while start.elapsed() < timeout {
 +            if let Some(event) = conn.poll_for_event()? {
 +                if let x11rb::protocol::Event::MapNotify(map_event) = event {
 +                    if map_event.window == window {
 +                        mapped = true;
 +                        tracing::debug!(elapsed_ms = start.elapsed().as_millis(), "Window mapped");
 +                        break;
 +                    }
 +                }
 +            }
 +            std::thread::sleep(Duration::from_millis(1));
 +        }
++
 +        if !mapped {
 +            tracing::warn!("MapNotify not received within timeout, continuing anyway");
 +        }
++
          // Grab keyboard - CRITICAL for security
          // Must retry because another application might have a grab
          Self::grab_keyboard(&conn, window)?;
              width,
              height,
              depth,
 +            overlay_window,
          })
+     }
 +    /// Try to get the XComposite overlay window
 +    ///
 +    /// The overlay window is rendered above the compositor's output,
 +    /// which is essential for screen lockers to work with compositors.
 +    fn get_overlay_window(conn: &RustConnection, root: Window) -> Option<Window> {
 +        // Query Composite extension version
 +        let version = match conn.composite_query_version(0, 4) {
 +            Ok(cookie) => match cookie.reply() {
 +                Ok(reply) => {
 +                    tracing::debug!(
 +                        "XComposite version {}.{}",
 +                        reply.major_version,
 +                        reply.minor_version
 +                    );
 +                    if reply.major_version == 0 && reply.minor_version < 3 {
 +                        tracing::warn!("XComposite version too old for overlay window");
 +                        return None;
 +                    }
 +                    (reply.major_version, reply.minor_version)
 +                }
 +                Err(e) => {
 +                    tracing::debug!("Failed to query XComposite version: {}", e);
 +                    return None;
 +                }
 +            },
 +            Err(e) => {
 +                tracing::debug!("XComposite extension not available: {}", e);
 +                return None;
 +            }
 +        };
++
 +        // Get the overlay window (requires Composite 0.3+)
 +        match conn.composite_get_overlay_window(root) {
 +            Ok(cookie) => match cookie.reply() {
 +                Ok(reply) => {
 +                    tracing::info!(
 +                        overlay_window = reply.overlay_win,
 +                        "Got XComposite overlay window"
 +                    );
 +                    Some(reply.overlay_win)
 +                }
 +                Err(e) => {
 +                    tracing::warn!("Failed to get overlay window: {}", e);
 +                    None
 +                }
 +            },
 +            Err(e) => {
 +                tracing::warn!("Failed to request overlay window: {}", e);
 +                None
 +            }
 +        }
 +    }
++
      /// Set fullscreen window hints
      fn set_fullscreen_hints(conn: &RustConnection, window: Window) -> Result<()> {
          let net_wm_state = conn
      /// Put an ARGB image to the window
      /// Splits large images into chunks to avoid exceeding X11 request limits
      pub fn put_image(&self, data: &[u8]) -> Result<()> {
 +        let expected_size = self.width as usize * self.height as usize * 4;
 +        if data.len() != expected_size {
 +            tracing::error!(
 +                "put_image size mismatch: data.len()={} expected={} ({}x{}x4)",
 +                data.len(),
 +                expected_size,
 +                self.width,
 +                self.height
 +            );
 +            anyhow::bail!(
 +                "Image data size {} doesn't match window {}x{} (expected {})",
 +                data.len(),
 +                self.width,
 +                self.height,
 +                expected_size
 +            );
 +        }
++
          let bytes_per_row = self.width as usize * 4;
          let total_rows = self.height as usize;
          let mut y_offset: i16 = 0;
          let mut remaining_rows = total_rows;
          let mut data_offset = 0;
 +        let mut chunks_sent = 0;
          while remaining_rows > 0 {
              let chunk_rows = remaining_rows.min(rows_per_chunk);
              y_offset += chunk_rows as i16;
              remaining_rows -= chunk_rows;
              data_offset += chunk_bytes;
 +            chunks_sent += 1;
+         }
          self.conn.flush().context("Failed to flush after put_image")?;
 +        tracing::trace!(chunks_sent, "put_image completed");
          Ok(())
+     }
          let _ = self.conn.ungrab_pointer(CURRENT_TIME);
          // Destroy window
          let _ = self.conn.destroy_window(self.window);
 +        // Release overlay window if we acquired it
 +        if let Some(overlay) = self.overlay_window {
 +            let root = self.conn.setup().roots[self.screen_num].root;
 +            let _ = self.conn.composite_release_overlay_window(root);
 +            tracing::debug!(overlay, "Released XComposite overlay window");
 +        }
          let _ = self.conn.flush();
          tracing::debug!("Locker window destroyed, grabs released");
+     }