monolith

//! Lazy Xwayland. monolith owns an X display socket from startup and only

//! starts Xwayland when a client connects, handing it the socket so the

//! connection that woke it is served. Xwayland exits once its last client

//! leaves and the socket is watched again.

use crate::state::State;

use smithay::desktop::Window;

use smithay::reexports::calloop::generic::Generic;

use smithay::reexports::calloop::{Interest, Mode, PostAction, RegistrationToken};

use smithay::reexports::rustix::io::{FdFlags, fcntl_getfd, fcntl_setfd};

use smithay::reexports::wayland_server::protocol::wl_surface::WlSurface;

use smithay::utils::{Logical, Rectangle, Size};

use smithay::wayland::xwayland_shell::{XWaylandShellHandler, XWaylandShellState};

use smithay::xwayland::xwm::{Reorder, ResizeEdge, WmWindowProperty, WmWindowType, XwmId};

use smithay::xwayland::{X11Surface, X11Wm, XWayland, XWaylandEvent, XwmHandler};

use std::os::fd::AsFd;

use std::os::linux::net::SocketAddrExt;

use std::os::unix::net::{SocketAddr, UnixListener};

use std::process::Stdio;

pub struct Xwayland {

    pub display: u32,

    listeners: Vec<UnixListener>,

    watch: Vec<(usize, RegistrationToken)>,

    running: bool,

    pub wm: Option<X11Wm>,

    /// Override-redirect windows such as menus and tooltips, bottom to top.

    pub unmanaged: Vec<X11Surface>,

}

impl Drop for Xwayland {

    fn drop(&mut self) {

        let _ = std::fs::remove_file(socket_path(self.display));

        let _ = std::fs::remove_file(lock_path(self.display));

    }

}

fn socket_path(n: u32) -> String {

    format!("/tmp/.X11-unix/X{n}")

}

fn lock_path(n: u32) -> String {

    format!("/tmp/.X{n}-lock")

}

/// Claims the first free X display, taking over stale locks left by dead

/// servers.

fn claim() -> Option<(u32, Vec<UnixListener>)> {

    let _ = std::fs::create_dir_all("/tmp/.X11-unix");

    for n in 0..64 {

        let lock = lock_path(n);

        let created = std::fs::OpenOptions::new()

            .write(true)

            .create_new(true)

            .open(&lock);

        let file = match created {

            Ok(f) => f,

            Err(_) => {

                let owner = std::fs::read_to_string(&lock)

                    .ok()

                    .and_then(|s| s.trim().parse::<u32>().ok());

                let stale = owner.is_some_and(|pid| !holds_display(pid));

                if !stale || std::fs::remove_file(&lock).is_err() {

                    continue;

                }

                match std::fs::OpenOptions::new()

                    .write(true)

                    .create_new(true)

                    .open(&lock)

                {

                    Ok(f) => f,

                    Err(_) => continue,

                }

            }

        };

        use std::io::Write;

        let _ = writeln!(&file, "{:>10}", std::process::id());

        let path = socket_path(n);

        let _ = std::fs::remove_file(&path);

        let Ok(fs) = UnixListener::bind(&path) else {

            let _ = std::fs::remove_file(&lock);

            continue;

        };

        let mut listeners = vec![fs];

        if let Ok(addr) = SocketAddr::from_abstract_name(path.as_bytes())

            && let Ok(abs) = UnixListener::bind_addr(&addr)

        {

            listeners.push(abs);

        }

        return Some((n, listeners));

    }

    None

}

pub fn init(state: &mut State) {

    let Some((number, listeners)) = claim() else {

        tracing::warn!("no free X display, X11 clients will not run");

        return;

    };

    let mut watch = Vec::new();

    for (i, l) in listeners.iter().enumerate() {

        let Ok(l) = l.try_clone() else { continue };

        let token = state.core.handle.insert_source(

            Generic::new(l, Interest::READ, Mode::Level),

            move |_, _, state| {

                start(state, i);

                Ok(PostAction::Disable)

            },

        );

        if let Ok(t) = token {

            watch.push((i, t));

        }

    }

    tracing::info!("X11 clients will start Xwayland on :{number}");

    state.services.xwayland = Some(Xwayland {

        display: number,

        listeners,

        watch,

        running: false,

        wm: None,

        unmanaged: Vec::new(),

    });

}

/// Waits for the next X client to knock.

fn rearm(state: &mut State) {

    let Some(x) = state.services.xwayland.as_mut() else {

        return;

    };

    x.running = false;

    for (_, t) in &x.watch {

        let _ = state.core.handle.enable(t);

    }

}

fn set_inherit(listeners: &[UnixListener], inherit: bool) {

    for l in listeners {

        let flags = fcntl_getfd(l.as_fd()).unwrap_or(FdFlags::CLOEXEC);

        let flags = if inherit {

            flags - FdFlags::CLOEXEC

        } else {

            flags | FdFlags::CLOEXEC

        };

        let _ = fcntl_setfd(l.as_fd(), flags);

    }

}

fn start(state: &mut State, fired: usize) {

    let Some(x) = state.services.xwayland.as_mut() else {

        return;

    };

    if x.running {

        return;

    }

    x.running = true;

    for (i, t) in &x.watch {

        if *i != fired {

            state.core.handle.disable(t).ok();

        }

    }

    let mut args = Vec::new();

    for l in &x.listeners {

        args.push("-listenfd".to_string());

        args.push(std::os::fd::AsRawFd::as_raw_fd(l).to_string());

    }

    // smithay only passes on the sockets it creates itself, so ours are

    // made inheritable just for this one spawn.

    set_inherit(&x.listeners, true);

    let spawned = XWayland::spawn(

        &state.core.display,

        None,

        std::iter::empty::<(String, String)>(),

        args,

        false,

        Stdio::null(),

        Stdio::null(),

        |_| {},

    );

    set_inherit(&x.listeners, false);

    let (xwayland, client) = match spawned {

        Ok(s) => s,

        Err(e) => {

            tracing::error!("cannot start Xwayland, X11 clients will not run: {e}");

            return;

        }

    };

    tracing::info!("starting Xwayland");

    let inserted = state

        .core

        .handle

        .insert_source(xwayland, move |event, _, state| match event {

            XWaylandEvent::Ready { x11_socket, .. } => {

                let dh = state.core.display.clone();

                match X11Wm::start_wm(state.core.handle.clone(), &dh, x11_socket, client.clone()) {

                    Ok(wm) => {

                        tracing::info!("Xwayland ready");

                        if let Some(x) = state.services.xwayland.as_mut() {

                            x.wm = Some(wm);

                        }

                    }

                    Err(e) => tracing::error!("cannot manage Xwayland windows: {e}"),

                }

            }

            XWaylandEvent::Error => {

                tracing::warn!("Xwayland failed to start");

                rearm(state);

            }

        });

    if let Err(e) = inserted {

        tracing::error!("cannot watch Xwayland: {e}");

    }

}

impl XWaylandShellHandler for State {

    fn xwayland_shell_state(&mut self) -> &mut XWaylandShellState {

        &mut self.protocols.xwayland_shell_state

    }

    fn surface_associated(&mut self, _xwm: XwmId, surface: WlSurface, window: X11Surface) {

        if let Some(id) = self.x11_window_id(&window) {

            self.wm.index(id);

        }

        self.on_buffer(&surface);

        self.dirty.redraw = true;

    }

}

impl XwmHandler for State {

    fn xwm_state(&mut self, _xwm: XwmId) -> &mut X11Wm {

        self.services

            .xwayland

            .as_mut()

            .and_then(|x| x.wm.as_mut())

            .expect("X11 events only arrive while the WM runs")

    }

    fn new_window(&mut self, _xwm: XwmId, _window: X11Surface) {}

    fn new_override_redirect_window(&mut self, _xwm: XwmId, _window: X11Surface) {}

    fn map_window_request(&mut self, _xwm: XwmId, window: X11Surface) {

        if let Err(e) = window.set_mapped(true) {

            tracing::warn!("cannot map X11 window: {e}");

            return;

        }

        let float = floats(&window).then(|| window.geometry());

        self.map_window(Window::new_x11_window(window), float);

    }

    fn mapped_override_redirect_window(&mut self, _xwm: XwmId, window: X11Surface) {

        if let Some(x) = self.services.xwayland.as_mut() {

            x.unmanaged.retain(|w| w != &window);

            x.unmanaged.push(window);

        }

        self.dirty.redraw = true;

    }

    fn unmapped_window(&mut self, _xwm: XwmId, window: X11Surface) {

        self.forget_x11(&window);

        if !window.is_override_redirect() {

            logged("unmap", window.set_mapped(false));

        }

    }

    fn destroyed_window(&mut self, _xwm: XwmId, window: X11Surface) {

        self.forget_x11(&window);

    }

    fn configure_request(

        &mut self,

        _xwm: XwmId,

        window: X11Surface,

        x: Option<i32>,

        y: Option<i32>,

        w: Option<u32>,

        h: Option<u32>,

        _reorder: Option<Reorder>,

    ) {

        if self.x11_window_id(&window).is_some() {

            logged("configure", window.configure(None));

            return;

        }

        let mut geo = window.geometry();

        geo.loc.x = x.unwrap_or(geo.loc.x);

        geo.loc.y = y.unwrap_or(geo.loc.y);

        geo.size.w = w.map_or(geo.size.w, |w| w as i32);

        geo.size.h = h.map_or(geo.size.h, |h| h as i32);

        logged("configure", window.configure(geo));

    }

    fn configure_notify(

        &mut self,

        _xwm: XwmId,

        window: X11Surface,

        _geometry: Rectangle<i32, Logical>,

        _above: Option<smithay::xwayland::xwm::X11Window>,

    ) {

        if window.is_override_redirect() {

            self.dirty.redraw = true;

        }

    }

    fn resize_request(

        &mut self,

        _xwm: XwmId,

        _window: X11Surface,

        _button: u32,

        _edge: ResizeEdge,

    ) {

    }

    fn move_request(&mut self, _xwm: XwmId, _window: X11Surface, _button: u32) {}

    fn fullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {

        self.x11_fullscreen(&window, true);

    }

    fn unfullscreen_request(&mut self, _xwm: XwmId, window: X11Surface) {

        self.x11_fullscreen(&window, false);

    }

    fn property_notify(&mut self, _xwm: XwmId, window: X11Surface, property: WmWindowProperty) {

        if matches!(property, WmWindowProperty::Title | WmWindowProperty::Class)

            && let Some(id) = self.x11_window_id(&window)

        {

            self.refresh_identity(id);

        }

    }

    fn disconnected(&mut self, _xwm: XwmId) {

        tracing::info!("Xwayland exited");

        let gone: Vec<_> = self

            .wm

            .iter()

            .filter(|(_, w)| w.window.x11_surface().is_some())

            .map(|(id, _)| id)

            .collect();

        for id in gone {

            self.remove_window(id);

        }

        if let Some(x) = self.services.xwayland.as_mut() {

            x.wm = None;

            x.unmanaged.clear();

        }

        rearm(self);

    }

}

/// Dialogs, splash screens and fixed-size windows float at their own size.

fn floats(window: &X11Surface) -> bool {

    let kind = matches!(

        window.window_type(),

        Some(

            WmWindowType::Dialog

                | WmWindowType::Splash

                | WmWindowType::Utility

                | WmWindowType::Toolbar

                | WmWindowType::Menu

        )

    );

    kind || fixed_size(window).is_some() || window.is_transient_for().is_some()

}

/// The size of a window that asks for exactly one.

pub fn fixed_size(window: &X11Surface) -> Option<Size<i32, Logical>> {

    match (window.min_size(), window.max_size()) {

        (Some(min), Some(max)) if min == max && min.w > 0 && min.h > 0 => Some(min),

        _ => None,

    }

}

impl State {

    pub fn x11_window_id(&self, window: &X11Surface) -> Option<monolith_layout::WindowId> {

        self.wm

            .iter()

            .find(|(_, w)| w.window.x11_surface() == Some(window))

            .map(|(id, _)| id)

    }

    fn forget_x11(&mut self, window: &X11Surface) {

        if let Some(x) = self.services.xwayland.as_mut() {

            x.unmanaged.retain(|w| w != window);

        }

        if let Some(id) = self.x11_window_id(window) {

            self.remove_window(id);

        }

        self.dirty.redraw = true;

    }

    fn x11_fullscreen(&mut self, window: &X11Surface, on: bool) {

        if let Some(id) = self.x11_window_id(window)

            && self

                .wm

                .layout

                .window(id)

                .is_some_and(|w| w.fullscreen != on)

        {

            self.wm.layout.toggle_fullscreen(id);

            self.wm.layout.focus_if_covering(id);

            self.apply_layout();

        }

    }

}

/// X11 requests fail when the window is already gone, which is routine, but

/// a failure on a live window means it never got the geometry we chose.

pub fn logged<E: std::fmt::Display>(what: &str, result: Result<(), E>) {

    if let Err(e) = result {

        tracing::debug!("X11 {what} failed: {e}");

    }

}

/// Whether `pid` is alive and could own an X display lock. A SIGKILLed

/// monolith leaves its lock behind, and its pid may since belong to anything.

fn holds_display(pid: u32) -> bool {

    std::fs::read_to_string(format!("/proc/{pid}/comm"))

        .is_ok_and(|comm| comm.starts_with('X') || comm.trim() == "monolith")

}