monolith

public

Star0

Fork 0

Watch0

322 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `706b42a51787`

tarball

atagen <boss@atagen.co>2026-10-19 10:59 UTC

1 file changed+69-11

xwayland: close a STRING relay that stops moving data

A selection owner that kept the pipe open without writing, or an X client that never read, left the relay's calloop source and both fds registered until the connection died. A timer now removes the live source after 30 s without progress.

Modified file: crates/monolith/src/xwayland.rs+69 additions−11 deletions@@ -9,6 +9,7 @@ use crate::state::State;
 use monolith_config::SelectionAccess;
 use smithay::desktop::Window;
 use smithay::reexports::calloop::generic::Generic;
+use smithay::reexports::calloop::timer::{TimeoutAction, Timer};
 use smithay::reexports::calloop::{Interest, LoopHandle, Mode, PostAction, RegistrationToken};
 use smithay::reexports::rustix::fs::{OFlags, fcntl_setfl};
 use smithay::reexports::rustix::io::{FdFlags, fcntl_getfd, fcntl_setfd};
@@ -26,6 +27,7 @@ use smithay::wayland::selection::primary_selection::{
 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::cell::Cell;
 use std::fs::File;
 use std::io::{ErrorKind, Read, Write};
 use std::os::fd::AsFd;
@@ -33,6 +35,8 @@ use std::os::fd::OwnedFd;
 use std::os::linux::net::SocketAddrExt;
 use std::os::unix::net::{SocketAddr, UnixListener};
 use std::process::Stdio;
+use std::rc::Rc;
+use std::time::{Duration, Instant};
 
 const UTF8_TEXT: [&str; 4] = [
     "text/plain;charset=utf-8",
@@ -45,6 +49,9 @@ const UTF8_TEXT: [&str; 4] = [
 /// grow the compositor without bound.
 const RELAY_CAP: usize = 16 << 20;
 
+/// How long a STRING relay may go without moving data before it is closed.
+const RELAY_IDLE: Duration = Duration::from_secs(30);
+
 fn utf8_source(mimes: &[String]) -> Option<&str> {
     UTF8_TEXT.into_iter().find(|t| mimes.iter().any(|m| m == t))
 }
@@ -65,17 +72,29 @@ fn latin1(text: &[u8]) -> Vec<u8> {
         .collect()
 }
 
+/// The live source of a STRING relay and when it last moved data, so a timer
+/// can close one that stalled.
+struct Relay {
+    source: Cell<Option<RegistrationToken>>,
+    moved: Cell<Instant>,
+}
+
 /// Hands back the write end of a pipe whose UTF-8 contents reach `out` as
 /// Latin-1, which is what ICCCM says STRING holds. Text past `RELAY_CAP` is
-/// dropped along with the transfer.
+/// dropped along with the transfer, and so is a transfer that moves nothing
+/// for `RELAY_IDLE`.
 fn latin1_relay(handle: &LoopHandle<'static, State>, out: OwnedFd) -> std::io::Result<OwnedFd> {
     let (read, write) = std::io::pipe()?;
     fcntl_setfl(&read, OFlags::NONBLOCK)?;
     fcntl_setfl(&out, OFlags::NONBLOCK)?;
+    let relay = Rc::new(Relay {
+        source: Cell::new(None),
+        moved: Cell::new(Instant::now()),
+    });
     let mut out = Some(File::from(out));
     let mut text = Vec::new();
-    let next = handle.clone();
-    handle
+    let (next, shared) = (handle.clone(), relay.clone());
+    let token = handle
         .insert_source(
             Generic::new(read, Interest::READ, Mode::Level),
             move |_, read, _| {
@@ -83,33 +102,54 @@ fn latin1_relay(handle: &LoopHandle<'static, State>, out: OwnedFd) -> std::io::R
                 loop {
                     match (&**read).read(&mut chunk) {
                         Ok(0) => break,
-                        Ok(n) if text.len() + n > RELAY_CAP => return Ok(PostAction::Remove),
-                        Ok(n) => text.extend_from_slice(&chunk[..n]),
+                        Ok(n) if text.len() + n > RELAY_CAP => {
+                            shared.source.set(None);
+                            return Ok(PostAction::Remove);
+                        }
+                        Ok(n) => {
+                            text.extend_from_slice(&chunk[..n]);
+                            shared.moved.set(Instant::now());
+                        }
                         Err(e) if e.kind() == ErrorKind::Interrupted => {}
                         Err(e) if e.kind() == ErrorKind::WouldBlock => {
                             return Ok(PostAction::Continue);
                         }
-                        Err(_) => return Ok(PostAction::Remove),
+                        Err(_) => {
+                            shared.source.set(None);
+                            return Ok(PostAction::Remove);
+                        }
                     }
                 }
+                shared.source.set(None);
                 if let Some(out) = out.take() {
-                    write_when_ready(&next, out, latin1(&text));
+                    write_when_ready(&next, &shared, out, latin1(&text));
                 }
                 Ok(PostAction::Remove)
             },
         )
         .map_err(|e| std::io::Error::other(e.to_string()))?;
+    relay.source.set(Some(token));
+    expire_when_stalled(handle, relay);
     Ok(write.into())
 }
 
-fn write_when_ready(handle: &LoopHandle<'static, State>, out: File, data: Vec<u8>) {
+fn write_when_ready(
+    handle: &LoopHandle<'static, State>,
+    relay: &Rc<Relay>,
+    out: File,
+    data: Vec<u8>,
+) {
     let mut sent = 0;
+    let shared = relay.clone();
     let inserted = handle.insert_source(
         Generic::new(out, Interest::WRITE, Mode::Level),
         move |_, out, _| {
             while sent < data.len() {
                 match (&**out).write(&data[sent..]) {
-                    Ok(n) => sent += n,
+                    Ok(n) => {
+                        sent += n;
+                        shared.moved.set(Instant::now());
+                    }
                     Err(e) if e.kind() == ErrorKind::Interrupted => {}
                     Err(e) if e.kind() == ErrorKind::WouldBlock => {
                         return Ok(PostAction::Continue);
@@ -117,14 +157,32 @@ fn write_when_ready(handle: &LoopHandle<'static, State>, out: File, data: Vec<u8
                     Err(_) => break,
                 }
             }
+            shared.source.set(None);
             Ok(PostAction::Remove)
         },
     );
-    if let Err(e) = inserted {
-        tracing::warn!("cannot relay STRING to X11: {e}");
+    match inserted {
+        Ok(token) => relay.source.set(Some(token)),
+        Err(e) => tracing::warn!("cannot relay STRING to X11: {e}"),
     }
 }
 
+fn expire_when_stalled(handle: &LoopHandle<'static, State>, relay: Rc<Relay>) {
+    let owner = handle.clone();
+    let _ = handle.insert_source(Timer::from_duration(RELAY_IDLE), move |_, _, _| {
+        let Some(token) = relay.source.get() else {
+            return TimeoutAction::Drop;
+        };
+        let idle = relay.moved.get().elapsed();
+        if idle < RELAY_IDLE {
+            return TimeoutAction::ToDuration(RELAY_IDLE - idle);
+        }
+        relay.source.set(None);
+        owner.remove(token);
+        TimeoutAction::Drop
+    });
+}
+
 pub struct Xwayland {
     pub display: u32,
     listeners: Vec<UnixListener>,

monolith

Commit 706b42a51787

Commit `706b42a51787`