fix(compositor): bind each app session's Wayland client to its session through appd

The compositor stored appd's (pid, session) announcements and never used
them, so no surface could be attributed to a session and any client
could claim any app ID or the panel role.

weft-appd now creates a connected socket pair for each session, gives
the app shell one end as standard input with WAYLAND_SOCKET=0 and no
WAYLAND_DISPLAY, and sends the other end to the compositor with the
session and app ID over the compositor IPC socket (SCM_RIGHTS). The
compositor inserts it as a client bound to that session: holding the
connection is the session's identity. A session's zweft_shell windows
carry its app ID, the panel and overlay roles are refused to sessions
with a new role_not_permitted error, the session's first toplevel is
reported to appd, an ended session's client is closed, and a client's
disconnection is reported. The compositor accepts one appd connection
at a time.

The counter desktop check now requires the compositor to bind the app's
client to its session and to close it when the session is terminated.
This commit is contained in:
Marco Allegretti 2026-10-09 15:07:33 +00:00
parent 5c82b540e6
commit 7cf8639ae3
No known key found for this signature in database
13 changed files with 570 additions and 98 deletions

2
Cargo.lock generated
View file

@ -10473,6 +10473,7 @@ dependencies = [
"futures-util", "futures-util",
"libc", "libc",
"rmp-serde", "rmp-serde",
"rustix 1.1.4",
"sd-notify", "sd-notify",
"serde", "serde",
"serde_json", "serde_json",
@ -10494,6 +10495,7 @@ version = "0.1.0"
dependencies = [ dependencies = [
"anyhow", "anyhow",
"bitflags 2.11.0", "bitflags 2.11.0",
"rustix 1.1.4",
"sd-notify", "sd-notify",
"smithay", "smithay",
"smithay-drm-extras", "smithay-drm-extras",

View file

@ -21,6 +21,7 @@ futures-util = { version = "0.3", default-features = false, features = ["sink",
tracing = "0.1" tracing = "0.1"
tracing-subscriber = { version = "0.3", features = ["env-filter"] } tracing-subscriber = { version = "0.3", features = ["env-filter"] }
libc = "0.2" libc = "0.2"
rustix = { version = "1", features = ["net"] }
[target.'cfg(unix)'.dependencies] [target.'cfg(unix)'.dependencies]
sd-notify = "0.4" sd-notify = "0.4"

View file

@ -1,3 +1,4 @@
use std::os::fd::OwnedFd;
use std::path::PathBuf; use std::path::PathBuf;
use tokio::io::AsyncWriteExt; use tokio::io::AsyncWriteExt;
@ -6,7 +7,19 @@ use weft_ipc_types::{
AppdToCompositor, CompositorToAppd, MAX_FRAME_LEN, frame_decode, frame_encode, AppdToCompositor, CompositorToAppd, MAX_FRAME_LEN, frame_decode, frame_encode,
}; };
pub type CompositorSender = mpsc::Sender<AppdToCompositor>; /// A message for the compositor and the file descriptor it carries, if any.
pub struct Outbound {
pub msg: AppdToCompositor,
pub fd: Option<OwnedFd>,
}
impl From<AppdToCompositor> for Outbound {
fn from(msg: AppdToCompositor) -> Self {
Self { msg, fd: None }
}
}
pub type CompositorSender = mpsc::Sender<Outbound>;
/// Resolve the compositor IPC socket path. /// Resolve the compositor IPC socket path.
/// ///
@ -26,15 +39,14 @@ pub fn socket_path() -> Option<PathBuf> {
/// ///
/// The task connects to `socket_path`, retrying every 2 s on failure. If the /// The task connects to `socket_path`, retrying every 2 s on failure. If the
/// connection drops while sending, it waits 500 ms then reconnects. Incoming /// connection drops while sending, it waits 500 ms then reconnects. Incoming
/// `CompositorToAppd` frames are decoded and logged; no behavioural action is /// `CompositorToAppd` frames are decoded and logged.
/// taken yet (surface lifecycle hookup happens in a later task).
pub fn spawn(socket_path: PathBuf) -> CompositorSender { pub fn spawn(socket_path: PathBuf) -> CompositorSender {
let (tx, rx) = mpsc::channel::<AppdToCompositor>(32); let (tx, rx) = mpsc::channel::<Outbound>(32);
tokio::spawn(run_client(socket_path, rx)); tokio::spawn(run_client(socket_path, rx));
tx tx
} }
async fn run_client(socket_path: PathBuf, mut rx: mpsc::Receiver<AppdToCompositor>) { async fn run_client(socket_path: PathBuf, mut rx: mpsc::Receiver<Outbound>) {
loop { loop {
let stream = loop { let stream = loop {
match tokio::net::UnixStream::connect(&socket_path).await { match tokio::net::UnixStream::connect(&socket_path).await {
@ -53,17 +65,22 @@ async fn run_client(socket_path: PathBuf, mut rx: mpsc::Receiver<AppdToComposito
tokio::spawn(read_unix_incoming(read_half)); tokio::spawn(read_unix_incoming(read_half));
loop { loop {
let Some(msg) = rx.recv().await else { let Some(outbound) = rx.recv().await else {
return; return;
}; };
match frame_encode(&msg) { let frame = match frame_encode(&outbound.msg) {
Ok(frame) => { Ok(frame) => frame,
if write_half.write_all(&frame).await.is_err() { Err(e) => {
tracing::warn!("compositor IPC write failed; reconnecting"); tracing::warn!(?e, "compositor IPC encode error");
break; continue;
}
} }
Err(e) => tracing::warn!(?e, "compositor IPC encode error"), };
if send_frame(&mut write_half, &frame, outbound.fd)
.await
.is_err()
{
tracing::warn!("compositor IPC write failed; reconnecting");
break;
} }
} }
@ -71,6 +88,45 @@ async fn run_client(socket_path: PathBuf, mut rx: mpsc::Receiver<AppdToComposito
} }
} }
/// Writes `frame`, attaching `fd` to its first bytes so the compositor
/// receives the descriptor together with the message it belongs to.
async fn send_frame(
stream: &mut tokio::net::unix::OwnedWriteHalf,
frame: &[u8],
fd: Option<OwnedFd>,
) -> std::io::Result<()> {
use rustix::net::{SendAncillaryBuffer, SendAncillaryMessage, SendFlags, sendmsg};
use std::mem::MaybeUninit;
use std::os::fd::AsFd;
let Some(fd) = fd else {
return stream.write_all(frame).await;
};
let socket: &tokio::net::UnixStream = stream.as_ref();
let sent = loop {
socket.writable().await?;
let result = socket.try_io(tokio::io::Interest::WRITABLE, || {
let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(1))];
let mut control = SendAncillaryBuffer::new(&mut space);
let fds = [fd.as_fd()];
control.push(SendAncillaryMessage::ScmRights(&fds));
sendmsg(
socket,
&[std::io::IoSlice::new(frame)],
&mut control,
SendFlags::NOSIGNAL,
)
.map_err(std::io::Error::from)
});
match result {
Err(e) if e.kind() == std::io::ErrorKind::WouldBlock => continue,
other => break other?,
}
};
// The descriptor travelled with the first bytes; the rest of a partly
// sent frame follows as plain data.
stream.write_all(&frame[sent..]).await
}
async fn read_unix_incoming(mut reader: tokio::net::unix::OwnedReadHalf) { async fn read_unix_incoming(mut reader: tokio::net::unix::OwnedReadHalf) {
use tokio::io::AsyncReadExt; use tokio::io::AsyncReadExt;
@ -110,8 +166,8 @@ fn handle_incoming(msg: CompositorToAppd) {
CompositorToAppd::SurfaceReady { session_id } => { CompositorToAppd::SurfaceReady { session_id } => {
tracing::debug!(session_id, "SurfaceReady from compositor"); tracing::debug!(session_id, "SurfaceReady from compositor");
} }
CompositorToAppd::ClientDisconnected { pid } => { CompositorToAppd::ClientDisconnected { session_id } => {
tracing::debug!(pid, "ClientDisconnected from compositor"); tracing::debug!(session_id, "ClientDisconnected from compositor");
} }
} }
} }

View file

@ -8,15 +8,7 @@ use anyhow::Context;
use tokio::io::AsyncWriteExt; use tokio::io::AsyncWriteExt;
use tokio::sync::Mutex; use tokio::sync::Mutex;
#[cfg(unix)]
mod compositor_client; mod compositor_client;
#[cfg(not(unix))]
mod compositor_client {
use tokio::sync::mpsc;
use weft_ipc_types::AppdToCompositor;
pub type CompositorSender = mpsc::Sender<AppdToCompositor>;
}
mod grants; mod grants;
mod ipc; mod ipc;
mod launch; mod launch;
@ -1249,6 +1241,116 @@ mod tests {
assert!(!session_ipc_socket_path(session_id).unwrap().exists()); assert!(!session_ipc_socket_path(session_id).unwrap().exists());
} }
#[tokio::test(flavor = "current_thread")]
async fn the_app_shell_connects_only_through_its_session_connection() {
use std::io::BufRead;
use std::os::unix::fs::PermissionsExt;
let _env = env_lock().lock().await;
use_test_runtime_dir();
let dir = std::env::temp_dir().join(format!("weft_test_attach_{}", std::process::id()));
let _ = std::fs::remove_dir_all(&dir);
let app = dir.join("store/org.example.attach");
write_test_package(&app, "org.example.attach", "");
// Each child writes its Wayland environment to its standard input,
// which only the app shell has connected to anything.
let child = dir.join("child.sh");
std::fs::write(
&child,
"#!/bin/sh\nprintf '%s %s\\n' \"${WAYLAND_SOCKET-unset}\" \
\"${WAYLAND_DISPLAY-unset}\" >&0 2>/dev/null\n\
echo READY $WEFT_READY_TOKEN\nexec sleep 1\n",
)
.unwrap();
std::fs::set_permissions(&child, std::fs::Permissions::from_mode(0o755)).unwrap();
let vars = [
("WEFT_RUNTIME_BIN", child.clone().into_os_string()),
("WEFT_APP_SHELL_BIN", child.clone().into_os_string()),
("WEFT_DISABLE_CGROUP", "1".into()),
("WEFT_APP_STORE", dir.join("store").into_os_string()),
("WAYLAND_DISPLAY", "wayland-ambient".into()),
];
let prior: Vec<_> = vars
.iter()
.map(|(k, _)| (*k, std::env::var_os(k)))
.collect();
for (key, value) in &vars {
// SAFETY: env_lock is held on a current_thread runtime.
unsafe { std::env::set_var(key, value) };
}
let registry = make_registry();
let (tx, mut compositor) = tokio::sync::mpsc::channel(8);
registry.lock().await.compositor_tx = Some(tx);
let mut rx = registry.lock().await.subscribe();
let ack = dispatch(
Request::LaunchApp {
app_id: "org.example.attach".into(),
surface_id: 0,
},
&registry,
)
.await;
let attached = tokio::time::timeout(std::time::Duration::from_secs(10), compositor.recv())
.await
.ok()
.flatten();
let stopped = tokio::time::timeout(std::time::Duration::from_secs(10), async {
while !matches!(
rx.recv().await,
Ok(Response::AppState {
state: AppStateKind::Stopped,
..
})
) {}
})
.await;
let released = compositor.try_recv().ok().map(|out| out.msg);
for (key, value) in prior {
// SAFETY: as above.
unsafe {
match value {
Some(v) => std::env::set_var(key, v),
None => std::env::remove_var(key),
}
}
}
let _ = std::fs::remove_dir_all(&dir);
let Response::LaunchAck { session_id, .. } = ack else {
panic!("{ack:?}");
};
assert!(stopped.is_ok(), "session did not stop");
let attached = attached.expect("no connection was handed to the compositor");
assert!(
matches!(
&attached.msg,
weft_ipc_types::AppdToCompositor::AttachClient { session_id: s, app_id }
if *s == session_id && app_id == "org.example.attach"
),
"{:?}",
attached.msg
);
// The compositor's end reaches the app shell, which sees only
// WAYLAND_SOCKET and no display to connect to instead.
let stream = std::os::unix::net::UnixStream::from(attached.fd.expect("no descriptor"));
stream
.set_read_timeout(Some(std::time::Duration::from_secs(5)))
.unwrap();
let mut line = String::new();
std::io::BufReader::new(stream)
.read_line(&mut line)
.unwrap();
assert_eq!(line.trim(), "0 unset");
assert!(
matches!(
released,
Some(weft_ipc_types::AppdToCompositor::AppSurfaceDestroyed { session_id: s })
if s == session_id
),
"{released:?}"
);
}
#[tokio::test(flavor = "current_thread")] #[tokio::test(flavor = "current_thread")]
async fn children_receive_the_resolved_package_files() { async fn children_receive_the_resolved_package_files() {
use std::os::unix::fs::PermissionsExt; use std::os::unix::fs::PermissionsExt;

View file

@ -191,8 +191,26 @@ fn spawn_app_shell(
package: &LaunchPackage, package: &LaunchPackage,
token: &str, token: &str,
bridge_token: Option<String>, bridge_token: Option<String>,
wayland: Option<std::os::unix::net::UnixStream>,
) -> std::io::Result<tokio::process::Child> { ) -> std::io::Result<tokio::process::Child> {
let mut command = tokio::process::Command::new(bin); let mut command = tokio::process::Command::new(bin);
match wayland {
// The app shell's only Wayland connection is the one created for its
// session, handed over as its standard input: WAYLAND_SOCKET names
// that descriptor, and no display socket is offered to connect
// anywhere else. Only this child receives the descriptor.
Some(stream) => {
command
.stdin(std::process::Stdio::from(std::os::fd::OwnedFd::from(
stream,
)))
.env("WAYLAND_SOCKET", "0")
.env_remove("WAYLAND_DISPLAY");
}
None => {
command.stdin(std::process::Stdio::null());
}
}
if let Some(bridge_token) = bridge_token { if let Some(bridge_token) = bridge_token {
// The page holds this credential; it must differ from the readiness // The page holds this credential; it must differ from the readiness
// token, which page output could otherwise use to fake readiness. // token, which page output could otherwise use to fake readiness.
@ -204,7 +222,6 @@ fn spawn_app_shell(
.arg("--ui") .arg("--ui")
.arg(&package.ui_entry) .arg(&package.ui_entry)
.env(READY_TOKEN_ENV, token) .env(READY_TOKEN_ENV, token)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::piped()) .stdout(std::process::Stdio::piped())
.stderr(std::process::Stdio::piped()) .stderr(std::process::Stdio::piped())
.kill_on_drop(true) .kill_on_drop(true)
@ -330,7 +347,7 @@ pub(crate) async fn supervise(
relay: Some(relay), relay: Some(relay),
image, image,
compositor_tx, compositor_tx,
surface_announced: false, client_attached: false,
}; };
let mut runtime = match cmd.spawn() { let mut runtime = match cmd.spawn() {
@ -341,23 +358,6 @@ pub(crate) async fn supervise(
.await; .await;
} }
}; };
if let Some(tx) = &session.compositor_tx {
let pid = runtime.id().unwrap_or(0);
// A full queue (compositor disconnected) must not stall the session.
session.surface_announced = tx
.try_send(AppdToCompositor::AppSurfaceCreated {
app_id: app_id.to_owned(),
session_id,
pid,
})
.is_ok();
if !session.surface_announced {
tracing::warn!(
session_id,
"compositor queue unavailable; surface not announced"
);
}
}
let runtime_stdout = runtime.stdout.take().expect("stdout piped"); let runtime_stdout = runtime.stdout.take().expect("stdout piped");
tokio::spawn(drain_stderr( tokio::spawn(drain_stderr(
runtime.stderr.take().expect("stderr piped"), runtime.stderr.take().expect("stderr piped"),
@ -377,16 +377,35 @@ pub(crate) async fn supervise(
}; };
tokio::spawn(drain_stdout(runtime_stdout, session_id)); tokio::spawn(drain_stdout(runtime_stdout, session_id));
let bridge_token = registry.lock().await.bridge_token(session_id); // With a compositor, the app shell connects only through a connection
let mut app_shell = // the compositor received for this session, so every surface it creates
match spawn_app_shell(&shell_bin, session_id, &package, &token, bridge_token) { // is bound to the session.
Ok(child) => child, let wayland = match &session.compositor_tx {
Err(e) => { None => None,
return session Some(tx) => match attach_client(tx, session_id, app_id) {
.settle(&registry, &format!("failed to spawn app shell: {e}")) Ok(stream) => {
.await; session.client_attached = true;
Some(stream)
} }
}; Err(reason) => return session.settle(&registry, &reason).await,
},
};
let bridge_token = registry.lock().await.bridge_token(session_id);
let mut app_shell = match spawn_app_shell(
&shell_bin,
session_id,
&package,
&token,
bridge_token,
wayland,
) {
Ok(child) => child,
Err(e) => {
return session
.settle(&registry, &format!("failed to spawn app shell: {e}"))
.await;
}
};
let shell_stdout = app_shell.stdout.take().expect("stdout piped"); let shell_stdout = app_shell.stdout.take().expect("stdout piped");
tokio::spawn(drain_stderr( tokio::spawn(drain_stderr(
app_shell.stderr.take().expect("stderr piped"), app_shell.stderr.take().expect("stderr piped"),
@ -438,6 +457,26 @@ pub(crate) async fn supervise(
session.settle(&registry, &reason).await session.settle(&registry, &reason).await
} }
/// Creates the session's Wayland connection and queues the compositor's end
/// for the compositor, returning the app shell's end.
fn attach_client(
tx: &CompositorSender,
session_id: u64,
app_id: &str,
) -> Result<std::os::unix::net::UnixStream, String> {
let (shell, compositor) = std::os::unix::net::UnixStream::pair()
.map_err(|e| format!("cannot create the app's Wayland connection: {e}"))?;
tx.try_send(crate::compositor_client::Outbound {
msg: AppdToCompositor::AttachClient {
session_id,
app_id: app_id.to_owned(),
},
fd: Some(compositor.into()),
})
.map_err(|_| "the compositor connection is not available".to_owned())?;
Ok(shell)
}
/// Marks a session that never started any process as stopped. /// Marks a session that never started any process as stopped.
async fn stop_unstarted( async fn stop_unstarted(
registry: &Registry, registry: &Registry,
@ -467,7 +506,8 @@ struct OwnedSession {
/// The mounted package image, released after both children have exited. /// The mounted package image, released after both children have exited.
image: Option<Mount>, image: Option<Mount>,
compositor_tx: Option<CompositorSender>, compositor_tx: Option<CompositorSender>,
surface_announced: bool, /// Whether the compositor was given this session's client connection.
client_attached: bool,
} }
impl OwnedSession { impl OwnedSession {
@ -476,10 +516,10 @@ impl OwnedSession {
tracing::info!(session_id, reason, "stopping session"); tracing::info!(session_id, reason, "stopping session");
kill_child(self.app_shell).await; kill_child(self.app_shell).await;
kill_child(self.runtime).await; kill_child(self.runtime).await;
if self.surface_announced if self.client_attached
&& let Some(tx) = &self.compositor_tx && let Some(tx) = &self.compositor_tx
&& tx && tx
.try_send(AppdToCompositor::AppSurfaceDestroyed { session_id }) .try_send(AppdToCompositor::AppSurfaceDestroyed { session_id }.into())
.is_err() .is_err()
{ {
tracing::warn!( tracing::warn!(

View file

@ -26,6 +26,7 @@ wayland-scanner = "0.31"
wayland-server = "0.31" wayland-server = "0.31"
wayland-backend = "0.3" wayland-backend = "0.3"
bitflags = "2" bitflags = "2"
rustix = { version = "1", features = ["net"] }
# DRM/KMS and hardware input depend on Linux kernel interfaces; compile only on Linux. # DRM/KMS and hardware input depend on Linux kernel interfaces; compile only on Linux.
[target.'cfg(target_os = "linux")'.dependencies] [target.'cfg(target_os = "linux")'.dependencies]

View file

@ -1,13 +1,17 @@
#[cfg(unix)] #[cfg(unix)]
use std::{ use std::{
collections::HashMap, collections::{HashMap, HashSet, VecDeque},
io::{self, Read, Write}, io,
os::fd::OwnedFd,
os::unix::net::{UnixListener, UnixStream}, os::unix::net::{UnixListener, UnixStream},
path::PathBuf, path::PathBuf,
sync::Arc,
}; };
#[cfg(unix)] #[cfg(unix)]
use smithay::reexports::calloop::{Interest, Mode, PostAction, generic::Generic}; use smithay::reexports::calloop::{Interest, Mode, PostAction, channel, generic::Generic};
#[cfg(unix)]
use smithay::reexports::wayland_server::backend::{ClientId, DisconnectReason};
#[cfg(unix)] #[cfg(unix)]
use weft_ipc_types::{ use weft_ipc_types::{
@ -15,15 +19,28 @@ use weft_ipc_types::{
}; };
#[cfg(unix)] #[cfg(unix)]
use crate::state::WeftCompositorState; use crate::state::{SessionBinding, WeftClientState, WeftCompositorState};
/// Descriptors received ahead of the messages that claim them; more than
/// this means the peer is not following the protocol.
#[cfg(unix)]
const MAX_PENDING_FDS: usize = 16;
#[cfg(unix)] #[cfg(unix)]
pub struct WeftAppdIpc { pub struct WeftAppdIpc {
pub socket_path: PathBuf, pub socket_path: PathBuf,
read_buf: Vec<u8>, read_buf: Vec<u8>,
write_stream: Option<UnixStream>, write_stream: Option<UnixStream>,
/// pid → (app_id, session_id) for Wayland clients whose surface has not yet arrived. /// Descriptors received with appd messages, in arrival order. Each
pub pending_pids: HashMap<u32, (String, u64)>, /// `AttachClient` frame is sent with exactly one, attached to its first
/// bytes, so it has arrived by the time the frame is decoded.
fds: VecDeque<OwnedFd>,
/// The Wayland client of each appd session.
sessions: HashMap<u64, ClientId>,
/// Sessions whose first toplevel was reported to appd.
reported: HashSet<u64>,
/// Where clients report their session's disconnection.
disconnected: Option<channel::Sender<u64>>,
} }
#[cfg(unix)] #[cfg(unix)]
@ -33,12 +50,15 @@ impl WeftAppdIpc {
socket_path, socket_path,
read_buf: Vec::new(), read_buf: Vec::new(),
write_stream: None, write_stream: None,
pending_pids: HashMap::new(), fds: VecDeque::new(),
sessions: HashMap::new(),
reported: HashSet::new(),
disconnected: None,
} }
} }
#[allow(dead_code)]
pub fn send(&mut self, msg: &CompositorToAppd) { pub fn send(&mut self, msg: &CompositorToAppd) {
use std::io::Write;
let Some(stream) = &mut self.write_stream else { let Some(stream) = &mut self.write_stream else {
return; return;
}; };
@ -52,6 +72,13 @@ impl WeftAppdIpc {
} }
} }
/// Reports a session's first toplevel to appd.
pub fn surface_created(&mut self, session_id: u64) {
if self.sessions.contains_key(&session_id) && self.reported.insert(session_id) {
self.send(&CompositorToAppd::SurfaceReady { session_id });
}
}
fn try_decode_frames(&mut self) -> Vec<AppdToCompositor> { fn try_decode_frames(&mut self) -> Vec<AppdToCompositor> {
let mut out = Vec::new(); let mut out = Vec::new();
loop { loop {
@ -83,17 +110,35 @@ impl WeftAppdIpc {
out out
} }
pub fn on_read(&mut self, stream: &mut UnixStream) -> (Vec<AppdToCompositor>, bool) { /// Reads what is available, keeping descriptors that arrive with the
/// data, and returns the complete messages and whether appd hung up.
pub fn on_read(&mut self, stream: &UnixStream) -> (Vec<AppdToCompositor>, bool) {
use rustix::net::{RecvAncillaryBuffer, RecvAncillaryMessage, RecvFlags, recvmsg};
use std::mem::MaybeUninit;
let mut buf = [0u8; 8192]; let mut buf = [0u8; 8192];
let mut eof = false; let mut eof = false;
loop { loop {
match stream.read(&mut buf) { let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(4))];
Ok(0) => { let mut control = RecvAncillaryBuffer::new(&mut space);
let received = recvmsg(
stream,
&mut [io::IoSliceMut::new(&mut buf)],
&mut control,
RecvFlags::CMSG_CLOEXEC | RecvFlags::DONTWAIT,
);
for message in control.drain() {
if let RecvAncillaryMessage::ScmRights(fds) = message {
self.fds.extend(fds);
}
}
match received {
Ok(msg) if msg.bytes == 0 => {
eof = true; eof = true;
break; break;
} }
Ok(n) => self.read_buf.extend_from_slice(&buf[..n]), Ok(msg) => self.read_buf.extend_from_slice(&buf[..msg.bytes]),
Err(e) if e.kind() == io::ErrorKind::WouldBlock => break, Err(rustix::io::Errno::AGAIN) => break,
Err(rustix::io::Errno::INTR) => continue,
Err(e) => { Err(e) => {
tracing::warn!(?e, "appd IPC stream read error"); tracing::warn!(?e, "appd IPC stream read error");
eof = true; eof = true;
@ -101,10 +146,15 @@ impl WeftAppdIpc {
} }
} }
} }
if self.fds.len() > MAX_PENDING_FDS {
tracing::warn!("appd sent descriptors without messages; disconnecting");
eof = true;
}
let messages = self.try_decode_frames(); let messages = self.try_decode_frames();
if eof { if eof {
self.write_stream = None; self.write_stream = None;
self.read_buf.clear(); self.read_buf.clear();
self.fds.clear();
} }
(messages, eof) (messages, eof)
} }
@ -113,18 +163,21 @@ impl WeftAppdIpc {
#[cfg(unix)] #[cfg(unix)]
fn handle_message(state: &mut WeftCompositorState, msg: AppdToCompositor) { fn handle_message(state: &mut WeftCompositorState, msg: AppdToCompositor) {
match msg { match msg {
AppdToCompositor::AppSurfaceCreated { AppdToCompositor::AttachClient { session_id, app_id } => {
app_id, attach_client(state, session_id, app_id);
session_id,
pid,
} => {
tracing::debug!(app_id, session_id, pid, "AppSurfaceCreated");
if let Some(ipc) = &mut state.appd_ipc {
ipc.pending_pids.insert(pid, (app_id, session_id));
}
} }
AppdToCompositor::AppSurfaceDestroyed { session_id } => { AppdToCompositor::AppSurfaceDestroyed { session_id } => {
tracing::debug!(session_id, "AppSurfaceDestroyed"); let Some(ipc) = state.appd_ipc.as_mut() else {
return;
};
ipc.reported.remove(&session_id);
if let Some(client) = ipc.sessions.remove(&session_id) {
tracing::info!(session_id, "closing the client of an ended session");
state
.display_handle
.backend_handle()
.kill_client(client, DisconnectReason::ConnectionClosed);
}
} }
AppdToCompositor::AppFocusRequest { session_id } => { AppdToCompositor::AppFocusRequest { session_id } => {
tracing::debug!(session_id, "AppFocusRequest"); tracing::debug!(session_id, "AppFocusRequest");
@ -132,6 +185,54 @@ fn handle_message(state: &mut WeftCompositorState, msg: AppdToCompositor) {
} }
} }
/// Makes the descriptor that came with an `AttachClient` message a Wayland
/// client bound to `session_id`.
#[cfg(unix)]
fn attach_client(state: &mut WeftCompositorState, session_id: u64, app_id: String) {
let Some(ipc) = state.appd_ipc.as_mut() else {
return;
};
let Some(fd) = ipc.fds.pop_front() else {
tracing::warn!(
session_id,
"AttachClient arrived without a connection; ignored"
);
return;
};
if !weft_ipc_types::package::is_valid_app_id(&app_id) {
tracing::warn!(session_id, "AttachClient with an invalid app ID; ignored");
return;
}
if ipc.sessions.contains_key(&session_id) {
tracing::warn!(
session_id,
"session already has a client; connection refused"
);
return;
}
let Some(disconnected) = ipc.disconnected.clone() else {
return;
};
let stream = UnixStream::from(fd);
let data = Arc::new(WeftClientState {
session: Some(SessionBinding {
session_id,
app_id: app_id.clone(),
disconnected,
}),
..WeftClientState::default()
});
match state.display_handle.insert_client(stream, data) {
Ok(client) => {
tracing::info!(session_id, %app_id, "client bound to session");
if let Some(ipc) = state.appd_ipc.as_mut() {
ipc.sessions.insert(session_id, client.id());
}
}
Err(e) => tracing::warn!(session_id, ?e, "cannot add the session's client"),
}
}
#[cfg(unix)] #[cfg(unix)]
pub fn compositor_socket_path() -> PathBuf { pub fn compositor_socket_path() -> PathBuf {
if let Ok(p) = std::env::var("WEFT_COMPOSITOR_SOCKET") { if let Ok(p) = std::env::var("WEFT_COMPOSITOR_SOCKET") {
@ -168,6 +269,25 @@ pub fn setup(state: &mut WeftCompositorState) -> anyhow::Result<()> {
tracing::info!(path = %socket_path.display(), "compositor IPC socket open"); tracing::info!(path = %socket_path.display(), "compositor IPC socket open");
// Clients bound to a session report their disconnection here.
let (sender, receiver) = channel::channel::<u64>();
if let Some(ipc) = state.appd_ipc.as_mut() {
ipc.disconnected = Some(sender);
}
state
.loop_handle
.insert_source(receiver, |event, _, state| {
if let channel::Event::Msg(session_id) = event
&& let Some(ipc) = state.appd_ipc.as_mut()
{
ipc.sessions.remove(&session_id);
ipc.reported.remove(&session_id);
tracing::info!(session_id, "session client disconnected");
ipc.send(&CompositorToAppd::ClientDisconnected { session_id });
}
})
.map_err(|e| anyhow::anyhow!("insert session disconnect source: {e}"))?;
let handle = state.loop_handle.clone(); let handle = state.loop_handle.clone();
state state
.loop_handle .loop_handle
@ -177,6 +297,18 @@ pub fn setup(state: &mut WeftCompositorState) -> anyhow::Result<()> {
loop { loop {
match listener.accept() { match listener.accept() {
Ok((stream, _addr)) => { Ok((stream, _addr)) => {
// One appd at a time: a second connection while
// one is live is refused rather than replacing it.
if state
.appd_ipc
.as_ref()
.is_some_and(|ipc| ipc.write_stream.is_some())
{
tracing::warn!(
"second compositor IPC connection refused; weft-appd is connected"
);
continue;
}
tracing::info!("weft-appd connected to compositor IPC"); tracing::info!("weft-appd connected to compositor IPC");
let write_clone = match stream.try_clone() { let write_clone = match stream.try_clone() {
Ok(c) => c, Ok(c) => c,
@ -188,6 +320,7 @@ pub fn setup(state: &mut WeftCompositorState) -> anyhow::Result<()> {
if let Some(ipc) = &mut state.appd_ipc { if let Some(ipc) = &mut state.appd_ipc {
ipc.write_stream = Some(write_clone); ipc.write_stream = Some(write_clone);
ipc.read_buf.clear(); ipc.read_buf.clear();
ipc.fds.clear();
} }
stream.set_nonblocking(true).ok(); stream.set_nonblocking(true).ok();
let _ = handle.insert_source( let _ = handle.insert_source(
@ -225,3 +358,70 @@ pub fn setup(state: &mut WeftCompositorState) -> anyhow::Result<()> {
Ok(()) Ok(())
} }
#[cfg(all(test, unix))]
mod tests {
use super::*;
use rustix::net::{SendAncillaryBuffer, SendAncillaryMessage, SendFlags, sendmsg};
use std::mem::MaybeUninit;
use std::os::fd::AsFd;
fn send_with_fd(stream: &UnixStream, bytes: &[u8], fd: &impl AsFd) {
let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(1))];
let mut control = SendAncillaryBuffer::new(&mut space);
let fds = [fd.as_fd()];
assert!(control.push(SendAncillaryMessage::ScmRights(&fds)));
let sent = sendmsg(
stream,
&[io::IoSlice::new(bytes)],
&mut control,
SendFlags::empty(),
)
.unwrap();
assert_eq!(sent, bytes.len());
}
#[test]
fn a_connection_arrives_with_the_message_that_claims_it() {
let (appd, compositor) = UnixStream::pair().unwrap();
compositor.set_nonblocking(true).unwrap();
let (shell, client) = UnixStream::pair().unwrap();
let frame = frame_encode(&AppdToCompositor::AttachClient {
session_id: 7,
app_id: "org.weft.demo.counter".into(),
})
.unwrap();
send_with_fd(&appd, &frame, &client);
drop(client);
let mut ipc = WeftAppdIpc::new(PathBuf::from("/nonexistent"));
let (messages, eof) = ipc.on_read(&compositor);
assert!(!eof);
assert!(matches!(
messages.as_slice(),
[AppdToCompositor::AttachClient { session_id: 7, .. }]
));
// The received descriptor is the other end of the shell's connection.
let received = UnixStream::from(ipc.fds.pop_front().expect("no descriptor"));
use std::io::{Read, Write};
(&shell).write_all(b"hello").unwrap();
let mut buf = [0u8; 5];
(&received).read_exact(&mut buf).unwrap();
assert_eq!(&buf, b"hello");
}
#[test]
fn descriptors_without_messages_end_the_connection() {
let (appd, compositor) = UnixStream::pair().unwrap();
compositor.set_nonblocking(true).unwrap();
let (_shell, client) = UnixStream::pair().unwrap();
let mut ipc = WeftAppdIpc::new(PathBuf::from("/nonexistent"));
for _ in 0..=MAX_PENDING_FDS {
send_with_fd(&appd, &[0], &client);
}
let (messages, eof) = ipc.on_read(&compositor);
assert!(messages.is_empty());
assert!(eof);
assert!(ipc.fds.is_empty());
}
}

View file

@ -53,11 +53,27 @@ use smithay::{
#[derive(Default)] #[derive(Default)]
pub struct WeftClientState { pub struct WeftClientState {
pub compositor_state: CompositorClientState, pub compositor_state: CompositorClientState,
/// The appd session this client's connection was created for. Clients
/// that connect through the display socket have none.
pub session: Option<SessionBinding>,
}
/// The appd session a client belongs to, established by weft-appd handing
/// the compositor the client's connection, never by the client itself.
pub struct SessionBinding {
pub session_id: u64,
pub app_id: String,
/// Reports the session's disconnection to the event loop.
pub disconnected: smithay::reexports::calloop::channel::Sender<u64>,
} }
impl ClientData for WeftClientState { impl ClientData for WeftClientState {
fn initialized(&self, _client_id: ClientId) {} fn initialized(&self, _client_id: ClientId) {}
fn disconnected(&self, _client_id: ClientId, _reason: DisconnectReason) {} fn disconnected(&self, _client_id: ClientId, _reason: DisconnectReason) {
if let Some(binding) = &self.session {
let _ = binding.disconnected.send(binding.session_id);
}
}
} }
/// Accumulated state for a multi-touch swipe gesture in progress. /// Accumulated state for a multi-touch swipe gesture in progress.
@ -241,8 +257,16 @@ impl XdgShellHandler for WeftCompositorState {
fn new_toplevel(&mut self, surface: ToplevelSurface) { fn new_toplevel(&mut self, surface: ToplevelSurface) {
surface.send_configure(); surface.send_configure();
let session = surface.wl_surface().client().and_then(|client| {
client
.get_data::<WeftClientState>()
.and_then(|data| data.session.as_ref().map(|s| s.session_id))
});
let window = Window::new_wayland_window(surface); let window = Window::new_wayland_window(surface);
self.space.map_element(window, (0, 0), false); self.space.map_element(window, (0, 0), false);
if let (Some(session_id), Some(ipc)) = (session, self.appd_ipc.as_mut()) {
ipc.surface_created(session_id);
}
} }
fn new_popup(&mut self, surface: PopupSurface, positioner: PositionerState) { fn new_popup(&mut self, surface: PopupSurface, positioner: PositionerState) {
@ -466,7 +490,7 @@ impl GlobalDispatch<ZweftShellManagerV1, ()> for WeftCompositorState {
impl Dispatch<ZweftShellManagerV1, ()> for WeftCompositorState { impl Dispatch<ZweftShellManagerV1, ()> for WeftCompositorState {
fn request( fn request(
state: &mut Self, state: &mut Self,
_client: &Client, client: &Client,
_resource: &ZweftShellManagerV1, _resource: &ZweftShellManagerV1,
request: zweft_shell_manager_v1::Request, request: zweft_shell_manager_v1::Request,
_data: &(), _data: &(),
@ -486,6 +510,14 @@ impl Dispatch<ZweftShellManagerV1, ()> for WeftCompositorState {
width, width,
height, height,
} => { } => {
// An application session's windows carry the identity appd
// bound to its connection, and only the trusted shell, which
// connects through the display socket, may take shell roles.
let session = client
.get_data::<WeftClientState>()
.and_then(|data| data.session.as_ref());
let shell_role = matches!(role.as_str(), "panel" | "overlay");
let app_id = session.map_or(app_id, |s| s.app_id.clone());
let is_panel = role == "panel"; let is_panel = role == "panel";
let window = data_init.init( let window = data_init.init(
id, id,
@ -497,6 +529,18 @@ impl Dispatch<ZweftShellManagerV1, ()> for WeftCompositorState {
closed: std::sync::atomic::AtomicBool::new(false), closed: std::sync::atomic::AtomicBool::new(false),
}, },
); );
if let Some(session) = session
&& shell_role
{
window.post_error(
crate::protocols::server::zweft_shell_window_v1::Error::RoleNotPermitted,
format!(
"session {} ({}) may not create shell windows",
session.session_id, session.app_id
),
);
return;
}
if is_panel { if is_panel {
let (ox, oy, ow, oh) = state let (ox, oy, ow, oh) = state
.space .space

View file

@ -10,11 +10,16 @@ pub const MAX_FRAME_LEN: usize = 4 * 1024 * 1024;
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")] #[serde(tag = "type", rename_all = "snake_case")]
pub enum AppdToCompositor { pub enum AppdToCompositor {
AppSurfaceCreated { /// Hands the compositor its end of the Wayland connection weft-appd
app_id: String, /// created for the session's app shell. The frame is sent with exactly
/// one file descriptor attached (SCM_RIGHTS): the compositor end of that
/// connection. Holding the connection is the session's identity; no
/// client-supplied ID or process ID is trusted for it.
AttachClient {
session_id: u64, session_id: u64,
pid: u32, app_id: String,
}, },
/// The session ended; the compositor closes its client and windows.
AppSurfaceDestroyed { AppSurfaceDestroyed {
session_id: u64, session_id: u64,
}, },
@ -27,8 +32,10 @@ pub enum AppdToCompositor {
#[derive(Debug, Clone, Serialize, Deserialize)] #[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(tag = "type", rename_all = "snake_case")] #[serde(tag = "type", rename_all = "snake_case")]
pub enum CompositorToAppd { pub enum CompositorToAppd {
/// The session's client mapped its first toplevel.
SurfaceReady { session_id: u64 }, SurfaceReady { session_id: u64 },
ClientDisconnected { pid: u32 }, /// The session's Wayland client disconnected.
ClientDisconnected { session_id: u64 },
} }
/// Encode a message as a length-prefixed MessagePack frame. /// Encode a message as a length-prefixed MessagePack frame.
@ -111,23 +118,17 @@ mod tests {
use super::*; use super::*;
#[test] #[test]
fn roundtrip_appd_to_compositor_surface_created() { fn roundtrip_appd_to_compositor_attach_client() {
let msg = AppdToCompositor::AppSurfaceCreated { let msg = AppdToCompositor::AttachClient {
app_id: "com.example.app".into(), app_id: "com.example.app".into(),
session_id: 42, session_id: 42,
pid: 1234,
}; };
let frame = frame_encode(&msg).unwrap(); let frame = frame_encode(&msg).unwrap();
let decoded: AppdToCompositor = frame_decode(&frame).unwrap(); let decoded: AppdToCompositor = frame_decode(&frame).unwrap();
match decoded { match decoded {
AppdToCompositor::AppSurfaceCreated { AppdToCompositor::AttachClient { app_id, session_id } => {
app_id,
session_id,
pid,
} => {
assert_eq!(app_id, "com.example.app"); assert_eq!(app_id, "com.example.app");
assert_eq!(session_id, 42); assert_eq!(session_id, 42);
assert_eq!(pid, 1234);
} }
_ => panic!("unexpected variant"), _ => panic!("unexpected variant"),
} }
@ -168,11 +169,11 @@ mod tests {
#[test] #[test]
fn roundtrip_compositor_to_appd_disconnected() { fn roundtrip_compositor_to_appd_disconnected() {
let msg = CompositorToAppd::ClientDisconnected { pid: 5678 }; let msg = CompositorToAppd::ClientDisconnected { session_id: 5678 };
let frame = frame_encode(&msg).unwrap(); let frame = frame_encode(&msg).unwrap();
let decoded: CompositorToAppd = frame_decode(&frame).unwrap(); let decoded: CompositorToAppd = frame_decode(&frame).unwrap();
match decoded { match decoded {
CompositorToAppd::ClientDisconnected { pid } => assert_eq!(pid, 5678), CompositorToAppd::ClientDisconnected { session_id } => assert_eq!(session_id, 5678),
_ => panic!("unexpected variant"), _ => panic!("unexpected variant"),
} }
} }

View file

@ -8,7 +8,7 @@ WEFT OS is a Wayland compositor and application runtime where every app is a Web
### weft-compositor ### weft-compositor
Smithay-based Wayland compositor. Implements the `zweft-shell-unstable-v1` protocol extension, which allows shell clients (servo-shell, app-shell) to register their surfaces as typed shell slots. Supports DRM/KMS and winit (software/dev) backends. Smithay-based Wayland compositor. Implements the `zweft-shell-unstable-v1` protocol extension, which allows shell clients (servo-shell, app-shell) to register their surfaces as typed shell slots. Each application session's Wayland connection is handed to the compositor by weft-appd, which binds the client to that session (see `security.md`). Supports DRM/KMS and winit (software/dev) backends.
### weft-servo-shell ### weft-servo-shell
@ -16,7 +16,7 @@ System UI host. Renders one WebView pointing at `system-ui.html` using the embed
### weft-app-shell ### weft-app-shell
Per-application Servo host. Spawned by `weft-appd` after the Wasm runtime signals READY. Takes `<app_id>`, `<session_id>` and `--ui <path>`, the UI document weft-appd resolved from the package; it never looks for the package itself. Injects the `weftIpc` WebSocket bridge into the page. The bridge authenticates with the per-session token from `WEFT_BRIDGE_TOKEN` and can only exchange messages with its own session. It is installed only in top-level documents inside the application's UI directory, and top-level navigation outside that directory is denied; framed documents never receive the bridge. Every resource the page loads (subresources, `fetch()`, XHR, workers and WebSocket handshakes) is checked by the shell: the page may load files inside its UI directory, also after symbolic links are resolved, inline `data:` and `blob:` resources, `about:blank` and the session bridge; any other local file or network destination, and every redirect, fails with a network error. Loads Servo does not attribute to the webview, such as `navigator.sendBeacon()`, are all refused. Network access belongs to the Wasm component, under its fetch grants. Servo's privileged `navigator.servo` interface, which can change engine preferences, is not exposed to `about:blank` or `about:srcdoc` documents (a fork patch; see `crates/weft-servo-shell/SERVO_PIN.md`). Registers with the compositor as window type `application`. Exits when the appd session ends. Per-application Servo host. Spawned by `weft-appd` after the Wasm runtime signals READY. Takes `<app_id>`, `<session_id>` and `--ui <path>`, the UI document weft-appd resolved from the package; it never looks for the package itself. Injects the `weftIpc` WebSocket bridge into the page. The bridge authenticates with the per-session token from `WEFT_BRIDGE_TOKEN` and can only exchange messages with its own session. It is installed only in top-level documents inside the application's UI directory, and top-level navigation outside that directory is denied; framed documents never receive the bridge. Every resource the page loads (subresources, `fetch()`, XHR, workers and WebSocket handshakes) is checked by the shell: the page may load files inside its UI directory, also after symbolic links are resolved, inline `data:` and `blob:` resources, `about:blank` and the session bridge; any other local file or network destination, and every redirect, fails with a network error. Loads Servo does not attribute to the webview, such as `navigator.sendBeacon()`, are all refused. Network access belongs to the Wasm component, under its fetch grants. Servo's privileged `navigator.servo` interface, which can change engine preferences, is not exposed to `about:blank` or `about:srcdoc` documents (a fork patch; see `crates/weft-servo-shell/SERVO_PIN.md`). Registers with the compositor as window type `application`, over the one Wayland connection weft-appd created for its session and passed as standard input (`WAYLAND_SOCKET=0`). Exits when the appd session ends.
### weft-appd ### weft-appd

View file

@ -30,7 +30,9 @@ For verified read-only package storage, `weft-pack build-image` produces an EROF
## Wayland Surface Isolation ## Wayland Surface Isolation
Each app registers its surface with the compositor via `zweft_shell_manager_v1`. The compositor enforces that each surface belongs to the session that created it. The app cannot render outside its assigned surface slot. Each app shell has exactly one Wayland connection, created for its session. weft-appd creates a connected socket pair, gives one end to the app shell as its standard input with `WAYLAND_SOCKET=0` and no `WAYLAND_DISPLAY`, and sends the other end to the compositor over the compositor IPC socket (`SCM_RIGHTS`) with the session ID and app ID. The compositor adds that end as a client bound to the session; the binding comes from appd holding the connection, never from an ID or process ID the client supplies. A session's `zweft_shell` windows carry the session's app ID whatever the client requests, and the shell-only `panel` and `overlay` roles are refused with a protocol error. When the session ends, the compositor closes its client; when the client disconnects, the compositor reports it to appd. The compositor accepts one appd connection at a time.
Not yet covered: the compositor IPC socket accepts any process of the user while no appd is connected, so the first connection after a restart is trusted as appd; window placement, stacking, focus and close are not yet decided by the compositor per session (all toplevels start at the origin); and the trusted system shell is identified only by connecting through the display socket, which any process of the user can open.
## JavaScript Engine (SpiderMonkey) ## JavaScript Engine (SpiderMonkey)

View file

@ -65,6 +65,11 @@
object identity; no separate window_id is exchanged. The object identity; no separate window_id is exchanged. The
compositor will emit configure on the new object to communicate the compositor will emit configure on the new object to communicate the
effective initial geometry and state. effective initial geometry and state.
For a client that the compositor associated with an application
session, the session's application identifier replaces the app_id
argument, and the panel and overlay roles are refused with the
role_not_permitted error on the new window.
</description> </description>
<arg name="id" type="new_id" interface="zweft_shell_window_v1" <arg name="id" type="new_id" interface="zweft_shell_window_v1"
summary="new window object"/> summary="new window object"/>
@ -114,6 +119,8 @@
<description summary="protocol errors"/> <description summary="protocol errors"/>
<entry name="defunct_window" value="0" <entry name="defunct_window" value="0"
summary="request sent after window_closed was received"/> summary="request sent after window_closed was received"/>
<entry name="role_not_permitted" value="1"
summary="an application session requested a shell-only role"/>
</enum> </enum>
<request name="destroy" type="destructor"> <request name="destroy" type="destructor">

View file

@ -169,9 +169,16 @@ def run(args, desktop, xdotool):
appd = AppdClient(port, token) appd = AppdClient(port, token)
appd.send({"type": "LAUNCH_APP", "app_id": APP_ID, "surface_id": 0}) appd.send({"type": "LAUNCH_APP", "app_id": APP_ID, "surface_id": 0})
try: try:
appd.wait_for(lambda m: m.get("type") == "APP_READY", STARTUP_TIMEOUT) ready = appd.wait_for(lambda m: m.get("type") == "APP_READY", STARTUP_TIMEOUT)
except TimeoutError: except TimeoutError:
raise AssertionError("no APP_READY") raise AssertionError("no APP_READY")
session_id = ready["session_id"]
# The app's only Wayland connection is the one appd handed the
# compositor for this session.
bound = f"client bound to session session_id={session_id} app_id={APP_ID}"
if bound not in desktop.log_text("compositor"):
raise AssertionError(f"the compositor did not bind the app's client: {bound!r}")
def capture_card(): def capture_card():
deadline = time.monotonic() + 10 deadline = time.monotonic() + 10
@ -213,6 +220,15 @@ def run(args, desktop, xdotool):
if states[3] != states[1]: if states[3] != states[1]:
raise AssertionError("count after ArrowDown does not match the count after one ArrowUp") raise AssertionError("count after ArrowDown does not match the count after one ArrowUp")
# Ending the session closes its client in the compositor.
appd.send({"type": "TERMINATE_APP", "session_id": session_id})
deadline = time.monotonic() + 15
closed = f"closing the client of an ended session session_id={session_id}"
while closed not in desktop.log_text("compositor"):
if time.monotonic() > deadline:
raise AssertionError(f"the compositor did not close the session's client: {closed!r}")
time.sleep(0.3)
def subprocess_run(xdotool, display, arguments): def subprocess_run(xdotool, display, arguments):
import subprocess import subprocess