monolith

public

Star0

Fork 0

Watch0

189 commits 1 branch 0 tags 0 releases1.5 MiB

Commit `8c987154f02d`

tarball

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

2 files changed+82-1

xwayland: serve STRING to X11 requestors as Latin-1

ICCCM defines STRING as ISO-8859-1 and old X11 clients ask for nothing else, but smithay's xwm only maps text/plain to UTF8_STRING and TEXT. Advertising STRING for text selections and relaying the Wayland source's UTF-8 through a Latin-1 transcode means those clients get readable text instead of raw UTF-8 bytes or a refusal.

Modified file: crates/monolith/src/seat.rs+1−1

@@ -53,7 +53,7 @@ impl SelectionHandler for State {

5353 };

5454 *x.wayland_selection(ty) = mimes.clone();

5555 if let Some(wm) = x.wm.as_mut()

56- && let Err(e) = wm.new_selection(ty, mimes)

56+ && let Err(e) = wm.new_selection(ty, mimes.map(crate::xwayland::with_string_target))

5757 {

5858 tracing::warn!("cannot set the X11 {ty:?} selection: {e:?}");

5959 }

Modified file: crates/monolith/src/xwayland.rs+81 additions@@ -9,6 +9,7 @@ use monolith_config::SelectionAccess;
 use smithay::desktop::Window;
 use smithay::reexports::calloop::generic::Generic;
 use smithay::reexports::calloop::{Interest, Mode, PostAction, RegistrationToken};
+use smithay::reexports::rustix::fs::{OFlags, fcntl_setfl};
 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};
@@ -24,12 +25,54 @@ 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::io::{Read, Write};
 use std::os::fd::AsFd;
 use std::os::fd::OwnedFd;
 use std::os::linux::net::SocketAddrExt;
 use std::os::unix::net::{SocketAddr, UnixListener};
 use std::process::Stdio;
 
+const UTF8_TEXT: [&str; 4] = [
+    "text/plain;charset=utf-8",
+    "text/plain;charset=UTF-8",
+    "UTF8_STRING",
+    "text/plain",
+];
+
+fn utf8_source(mimes: &[String]) -> Option<&str> {
+    UTF8_TEXT.into_iter().find(|t| mimes.iter().any(|m| m == t))
+}
+
+/// X11 requestors that predate UTF8_STRING only ask for STRING, which smithay
+/// leaves out of the targets it offers for a Wayland-owned text selection.
+pub fn with_string_target(mut mimes: Vec<String>) -> Vec<String> {
+    if utf8_source(&mimes).is_some() && !mimes.iter().any(|m| m == "STRING") {
+        mimes.push("STRING".into());
+    }
+    mimes
+}
+
+fn latin1(text: &[u8]) -> Vec<u8> {
+    String::from_utf8_lossy(text)
+        .chars()
+        .map(|c| u8::try_from(u32::from(c)).unwrap_or(b'?'))
+        .collect()
+}
+
+/// Hands back the write end of a pipe whose UTF-8 contents reach `out` as
+/// Latin-1, which is what ICCCM says STRING holds.
+fn latin1_relay(out: OwnedFd) -> std::io::Result<OwnedFd> {
+    let (mut read, write) = std::io::pipe()?;
+    fcntl_setfl(&out, OFlags::empty())?;
+    std::thread::spawn(move || {
+        let mut text = Vec::new();
+        if read.read_to_end(&mut text).is_ok() {
+            let _ = std::fs::File::from(out).write_all(&latin1(&text));
+        }
+    });
+    Ok(write.into())
+}
+
 pub struct Xwayland {
     pub display: u32,
     listeners: Vec<UnixListener>,
@@ -222,6 +265,7 @@ fn start(state: &mut State, fired: usize) {
                         if let Some(x) = state.services.xwayland.as_mut() {
                             for ty in [SelectionTarget::Clipboard, SelectionTarget::Primary] {
                                 if let Some(mimes) = x.wayland_selection(ty).clone() {
+                                    let mimes = with_string_target(mimes);
                                     logged("selection", wm.new_selection(ty, Some(mimes)));
                                 }
                             }
@@ -372,6 +416,23 @@ impl XwmHandler for State {
         mime_type: String,
         fd: OwnedFd,
     ) {
+        let (mime_type, fd) = if mime_type == "STRING" {
+            let source = self.services.xwayland.as_mut().and_then(|x| {
+                let mimes = x.wayland_selection(selection).as_deref()?;
+                utf8_source(mimes).map(str::to_owned)
+            });
+            let relay = source.map(|s| latin1_relay(fd).map(|w| (s, w)));
+            match relay {
+                Some(Ok(relay)) => relay,
+                Some(Err(e)) => {
+                    tracing::warn!("cannot relay {selection:?} to X11 as STRING: {e}");
+                    return;
+                }
+                None => return,
+            }
+        } else {
+            (mime_type, fd)
+        };
         let seat = &self.input.seat;
         let result = match selection {
             SelectionTarget::Clipboard => request_data_device_client_selection(seat, mime_type, fd)
@@ -502,3 +563,23 @@ 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")
 }
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn latin1_keeps_the_range_and_replaces_the_rest() {
+        assert_eq!(latin1("café ÿ".as_bytes()), b"caf\xe9 \xff");
+        assert_eq!(latin1("a€😀".as_bytes()), b"a??");
+        assert_eq!(latin1(b"a\xc3"), b"a?");
+    }
+
+    #[test]
+    fn string_is_offered_for_text_only() {
+        let text = vec!["text/plain;charset=utf-8".to_string()];
+        assert_eq!(with_string_target(text).last().unwrap(), "STRING");
+        let image = vec!["image/png".to_string()];
+        assert_eq!(with_string_target(image.clone()), image);
+    }
+}

monolith

Commit 8c987154f02d

Commit `8c987154f02d`