mirror of
https://github.com/marcoallegretti/WEFT_OS.git
synced 2026-11-22 08:13:59 +00:00
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:
parent
5c82b540e6
commit
7cf8639ae3
13 changed files with 570 additions and 98 deletions
2
Cargo.lock
generated
2
Cargo.lock
generated
|
|
@ -10473,6 +10473,7 @@ dependencies = [
|
|||
"futures-util",
|
||||
"libc",
|
||||
"rmp-serde",
|
||||
"rustix 1.1.4",
|
||||
"sd-notify",
|
||||
"serde",
|
||||
"serde_json",
|
||||
|
|
@ -10494,6 +10495,7 @@ version = "0.1.0"
|
|||
dependencies = [
|
||||
"anyhow",
|
||||
"bitflags 2.11.0",
|
||||
"rustix 1.1.4",
|
||||
"sd-notify",
|
||||
"smithay",
|
||||
"smithay-drm-extras",
|
||||
|
|
|
|||
|
|
@ -21,6 +21,7 @@ futures-util = { version = "0.3", default-features = false, features = ["sink",
|
|||
tracing = "0.1"
|
||||
tracing-subscriber = { version = "0.3", features = ["env-filter"] }
|
||||
libc = "0.2"
|
||||
rustix = { version = "1", features = ["net"] }
|
||||
|
||||
[target.'cfg(unix)'.dependencies]
|
||||
sd-notify = "0.4"
|
||||
|
|
|
|||
|
|
@ -1,3 +1,4 @@
|
|||
use std::os::fd::OwnedFd;
|
||||
use std::path::PathBuf;
|
||||
|
||||
use tokio::io::AsyncWriteExt;
|
||||
|
|
@ -6,7 +7,19 @@ use weft_ipc_types::{
|
|||
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.
|
||||
///
|
||||
|
|
@ -26,15 +39,14 @@ pub fn socket_path() -> Option<PathBuf> {
|
|||
///
|
||||
/// 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
|
||||
/// `CompositorToAppd` frames are decoded and logged; no behavioural action is
|
||||
/// taken yet (surface lifecycle hookup happens in a later task).
|
||||
/// `CompositorToAppd` frames are decoded and logged.
|
||||
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));
|
||||
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 {
|
||||
let stream = loop {
|
||||
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));
|
||||
|
||||
loop {
|
||||
let Some(msg) = rx.recv().await else {
|
||||
let Some(outbound) = rx.recv().await else {
|
||||
return;
|
||||
};
|
||||
match frame_encode(&msg) {
|
||||
Ok(frame) => {
|
||||
if write_half.write_all(&frame).await.is_err() {
|
||||
tracing::warn!("compositor IPC write failed; reconnecting");
|
||||
break;
|
||||
}
|
||||
let frame = match frame_encode(&outbound.msg) {
|
||||
Ok(frame) => frame,
|
||||
Err(e) => {
|
||||
tracing::warn!(?e, "compositor IPC encode error");
|
||||
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) {
|
||||
use tokio::io::AsyncReadExt;
|
||||
|
||||
|
|
@ -110,8 +166,8 @@ fn handle_incoming(msg: CompositorToAppd) {
|
|||
CompositorToAppd::SurfaceReady { session_id } => {
|
||||
tracing::debug!(session_id, "SurfaceReady from compositor");
|
||||
}
|
||||
CompositorToAppd::ClientDisconnected { pid } => {
|
||||
tracing::debug!(pid, "ClientDisconnected from compositor");
|
||||
CompositorToAppd::ClientDisconnected { session_id } => {
|
||||
tracing::debug!(session_id, "ClientDisconnected from compositor");
|
||||
}
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,15 +8,7 @@ use anyhow::Context;
|
|||
use tokio::io::AsyncWriteExt;
|
||||
use tokio::sync::Mutex;
|
||||
|
||||
#[cfg(unix)]
|
||||
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 ipc;
|
||||
mod launch;
|
||||
|
|
@ -1249,6 +1241,116 @@ mod tests {
|
|||
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,
|
||||
},
|
||||
®istry,
|
||||
)
|
||||
.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")]
|
||||
async fn children_receive_the_resolved_package_files() {
|
||||
use std::os::unix::fs::PermissionsExt;
|
||||
|
|
|
|||
|
|
@ -191,8 +191,26 @@ fn spawn_app_shell(
|
|||
package: &LaunchPackage,
|
||||
token: &str,
|
||||
bridge_token: Option<String>,
|
||||
wayland: Option<std::os::unix::net::UnixStream>,
|
||||
) -> std::io::Result<tokio::process::Child> {
|
||||
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 {
|
||||
// The page holds this credential; it must differ from the readiness
|
||||
// token, which page output could otherwise use to fake readiness.
|
||||
|
|
@ -204,7 +222,6 @@ fn spawn_app_shell(
|
|||
.arg("--ui")
|
||||
.arg(&package.ui_entry)
|
||||
.env(READY_TOKEN_ENV, token)
|
||||
.stdin(std::process::Stdio::null())
|
||||
.stdout(std::process::Stdio::piped())
|
||||
.stderr(std::process::Stdio::piped())
|
||||
.kill_on_drop(true)
|
||||
|
|
@ -330,7 +347,7 @@ pub(crate) async fn supervise(
|
|||
relay: Some(relay),
|
||||
image,
|
||||
compositor_tx,
|
||||
surface_announced: false,
|
||||
client_attached: false,
|
||||
};
|
||||
|
||||
let mut runtime = match cmd.spawn() {
|
||||
|
|
@ -341,23 +358,6 @@ pub(crate) async fn supervise(
|
|||
.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");
|
||||
tokio::spawn(drain_stderr(
|
||||
runtime.stderr.take().expect("stderr piped"),
|
||||
|
|
@ -377,16 +377,35 @@ pub(crate) async fn supervise(
|
|||
};
|
||||
tokio::spawn(drain_stdout(runtime_stdout, session_id));
|
||||
|
||||
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) {
|
||||
Ok(child) => child,
|
||||
Err(e) => {
|
||||
return session
|
||||
.settle(®istry, &format!("failed to spawn app shell: {e}"))
|
||||
.await;
|
||||
// With a compositor, the app shell connects only through a connection
|
||||
// the compositor received for this session, so every surface it creates
|
||||
// is bound to the session.
|
||||
let wayland = match &session.compositor_tx {
|
||||
None => None,
|
||||
Some(tx) => match attach_client(tx, session_id, app_id) {
|
||||
Ok(stream) => {
|
||||
session.client_attached = true;
|
||||
Some(stream)
|
||||
}
|
||||
};
|
||||
Err(reason) => return session.settle(®istry, &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(®istry, &format!("failed to spawn app shell: {e}"))
|
||||
.await;
|
||||
}
|
||||
};
|
||||
let shell_stdout = app_shell.stdout.take().expect("stdout piped");
|
||||
tokio::spawn(drain_stderr(
|
||||
app_shell.stderr.take().expect("stderr piped"),
|
||||
|
|
@ -438,6 +457,26 @@ pub(crate) async fn supervise(
|
|||
session.settle(®istry, &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.
|
||||
async fn stop_unstarted(
|
||||
registry: &Registry,
|
||||
|
|
@ -467,7 +506,8 @@ struct OwnedSession {
|
|||
/// The mounted package image, released after both children have exited.
|
||||
image: Option<Mount>,
|
||||
compositor_tx: Option<CompositorSender>,
|
||||
surface_announced: bool,
|
||||
/// Whether the compositor was given this session's client connection.
|
||||
client_attached: bool,
|
||||
}
|
||||
|
||||
impl OwnedSession {
|
||||
|
|
@ -476,10 +516,10 @@ impl OwnedSession {
|
|||
tracing::info!(session_id, reason, "stopping session");
|
||||
kill_child(self.app_shell).await;
|
||||
kill_child(self.runtime).await;
|
||||
if self.surface_announced
|
||||
if self.client_attached
|
||||
&& let Some(tx) = &self.compositor_tx
|
||||
&& tx
|
||||
.try_send(AppdToCompositor::AppSurfaceDestroyed { session_id })
|
||||
.try_send(AppdToCompositor::AppSurfaceDestroyed { session_id }.into())
|
||||
.is_err()
|
||||
{
|
||||
tracing::warn!(
|
||||
|
|
|
|||
|
|
@ -26,6 +26,7 @@ wayland-scanner = "0.31"
|
|||
wayland-server = "0.31"
|
||||
wayland-backend = "0.3"
|
||||
bitflags = "2"
|
||||
rustix = { version = "1", features = ["net"] }
|
||||
|
||||
# DRM/KMS and hardware input depend on Linux kernel interfaces; compile only on Linux.
|
||||
[target.'cfg(target_os = "linux")'.dependencies]
|
||||
|
|
|
|||
|
|
@ -1,13 +1,17 @@
|
|||
#[cfg(unix)]
|
||||
use std::{
|
||||
collections::HashMap,
|
||||
io::{self, Read, Write},
|
||||
collections::{HashMap, HashSet, VecDeque},
|
||||
io,
|
||||
os::fd::OwnedFd,
|
||||
os::unix::net::{UnixListener, UnixStream},
|
||||
path::PathBuf,
|
||||
sync::Arc,
|
||||
};
|
||||
|
||||
#[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)]
|
||||
use weft_ipc_types::{
|
||||
|
|
@ -15,15 +19,28 @@ use weft_ipc_types::{
|
|||
};
|
||||
|
||||
#[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)]
|
||||
pub struct WeftAppdIpc {
|
||||
pub socket_path: PathBuf,
|
||||
read_buf: Vec<u8>,
|
||||
write_stream: Option<UnixStream>,
|
||||
/// pid → (app_id, session_id) for Wayland clients whose surface has not yet arrived.
|
||||
pub pending_pids: HashMap<u32, (String, u64)>,
|
||||
/// Descriptors received with appd messages, in arrival order. Each
|
||||
/// `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)]
|
||||
|
|
@ -33,12 +50,15 @@ impl WeftAppdIpc {
|
|||
socket_path,
|
||||
read_buf: Vec::new(),
|
||||
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) {
|
||||
use std::io::Write;
|
||||
let Some(stream) = &mut self.write_stream else {
|
||||
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> {
|
||||
let mut out = Vec::new();
|
||||
loop {
|
||||
|
|
@ -83,17 +110,35 @@ impl WeftAppdIpc {
|
|||
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 eof = false;
|
||||
loop {
|
||||
match stream.read(&mut buf) {
|
||||
Ok(0) => {
|
||||
let mut space = [MaybeUninit::uninit(); rustix::cmsg_space!(ScmRights(4))];
|
||||
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;
|
||||
break;
|
||||
}
|
||||
Ok(n) => self.read_buf.extend_from_slice(&buf[..n]),
|
||||
Err(e) if e.kind() == io::ErrorKind::WouldBlock => break,
|
||||
Ok(msg) => self.read_buf.extend_from_slice(&buf[..msg.bytes]),
|
||||
Err(rustix::io::Errno::AGAIN) => break,
|
||||
Err(rustix::io::Errno::INTR) => continue,
|
||||
Err(e) => {
|
||||
tracing::warn!(?e, "appd IPC stream read error");
|
||||
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();
|
||||
if eof {
|
||||
self.write_stream = None;
|
||||
self.read_buf.clear();
|
||||
self.fds.clear();
|
||||
}
|
||||
(messages, eof)
|
||||
}
|
||||
|
|
@ -113,18 +163,21 @@ impl WeftAppdIpc {
|
|||
#[cfg(unix)]
|
||||
fn handle_message(state: &mut WeftCompositorState, msg: AppdToCompositor) {
|
||||
match msg {
|
||||
AppdToCompositor::AppSurfaceCreated {
|
||||
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::AttachClient { session_id, app_id } => {
|
||||
attach_client(state, session_id, app_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 } => {
|
||||
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)]
|
||||
pub fn compositor_socket_path() -> PathBuf {
|
||||
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");
|
||||
|
||||
// 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();
|
||||
state
|
||||
.loop_handle
|
||||
|
|
@ -177,6 +297,18 @@ pub fn setup(state: &mut WeftCompositorState) -> anyhow::Result<()> {
|
|||
loop {
|
||||
match listener.accept() {
|
||||
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");
|
||||
let write_clone = match stream.try_clone() {
|
||||
Ok(c) => c,
|
||||
|
|
@ -188,6 +320,7 @@ pub fn setup(state: &mut WeftCompositorState) -> anyhow::Result<()> {
|
|||
if let Some(ipc) = &mut state.appd_ipc {
|
||||
ipc.write_stream = Some(write_clone);
|
||||
ipc.read_buf.clear();
|
||||
ipc.fds.clear();
|
||||
}
|
||||
stream.set_nonblocking(true).ok();
|
||||
let _ = handle.insert_source(
|
||||
|
|
@ -225,3 +358,70 @@ pub fn setup(state: &mut WeftCompositorState) -> anyhow::Result<()> {
|
|||
|
||||
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());
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -53,11 +53,27 @@ use smithay::{
|
|||
#[derive(Default)]
|
||||
pub struct WeftClientState {
|
||||
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 {
|
||||
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.
|
||||
|
|
@ -241,8 +257,16 @@ impl XdgShellHandler for WeftCompositorState {
|
|||
|
||||
fn new_toplevel(&mut self, surface: ToplevelSurface) {
|
||||
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);
|
||||
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) {
|
||||
|
|
@ -466,7 +490,7 @@ impl GlobalDispatch<ZweftShellManagerV1, ()> for WeftCompositorState {
|
|||
impl Dispatch<ZweftShellManagerV1, ()> for WeftCompositorState {
|
||||
fn request(
|
||||
state: &mut Self,
|
||||
_client: &Client,
|
||||
client: &Client,
|
||||
_resource: &ZweftShellManagerV1,
|
||||
request: zweft_shell_manager_v1::Request,
|
||||
_data: &(),
|
||||
|
|
@ -486,6 +510,14 @@ impl Dispatch<ZweftShellManagerV1, ()> for WeftCompositorState {
|
|||
width,
|
||||
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 window = data_init.init(
|
||||
id,
|
||||
|
|
@ -497,6 +529,18 @@ impl Dispatch<ZweftShellManagerV1, ()> for WeftCompositorState {
|
|||
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 {
|
||||
let (ox, oy, ow, oh) = state
|
||||
.space
|
||||
|
|
|
|||
|
|
@ -10,11 +10,16 @@ pub const MAX_FRAME_LEN: usize = 4 * 1024 * 1024;
|
|||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(tag = "type", rename_all = "snake_case")]
|
||||
pub enum AppdToCompositor {
|
||||
AppSurfaceCreated {
|
||||
app_id: String,
|
||||
/// Hands the compositor its end of the Wayland connection weft-appd
|
||||
/// 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,
|
||||
pid: u32,
|
||||
app_id: String,
|
||||
},
|
||||
/// The session ended; the compositor closes its client and windows.
|
||||
AppSurfaceDestroyed {
|
||||
session_id: u64,
|
||||
},
|
||||
|
|
@ -27,8 +32,10 @@ pub enum AppdToCompositor {
|
|||
#[derive(Debug, Clone, Serialize, Deserialize)]
|
||||
#[serde(tag = "type", rename_all = "snake_case")]
|
||||
pub enum CompositorToAppd {
|
||||
/// The session's client mapped its first toplevel.
|
||||
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.
|
||||
|
|
@ -111,23 +118,17 @@ mod tests {
|
|||
use super::*;
|
||||
|
||||
#[test]
|
||||
fn roundtrip_appd_to_compositor_surface_created() {
|
||||
let msg = AppdToCompositor::AppSurfaceCreated {
|
||||
fn roundtrip_appd_to_compositor_attach_client() {
|
||||
let msg = AppdToCompositor::AttachClient {
|
||||
app_id: "com.example.app".into(),
|
||||
session_id: 42,
|
||||
pid: 1234,
|
||||
};
|
||||
let frame = frame_encode(&msg).unwrap();
|
||||
let decoded: AppdToCompositor = frame_decode(&frame).unwrap();
|
||||
match decoded {
|
||||
AppdToCompositor::AppSurfaceCreated {
|
||||
app_id,
|
||||
session_id,
|
||||
pid,
|
||||
} => {
|
||||
AppdToCompositor::AttachClient { app_id, session_id } => {
|
||||
assert_eq!(app_id, "com.example.app");
|
||||
assert_eq!(session_id, 42);
|
||||
assert_eq!(pid, 1234);
|
||||
}
|
||||
_ => panic!("unexpected variant"),
|
||||
}
|
||||
|
|
@ -168,11 +169,11 @@ mod tests {
|
|||
|
||||
#[test]
|
||||
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 decoded: CompositorToAppd = frame_decode(&frame).unwrap();
|
||||
match decoded {
|
||||
CompositorToAppd::ClientDisconnected { pid } => assert_eq!(pid, 5678),
|
||||
CompositorToAppd::ClientDisconnected { session_id } => assert_eq!(session_id, 5678),
|
||||
_ => panic!("unexpected variant"),
|
||||
}
|
||||
}
|
||||
|
|
|
|||
|
|
@ -8,7 +8,7 @@ WEFT OS is a Wayland compositor and application runtime where every app is a Web
|
|||
|
||||
### 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
|
||||
|
||||
|
|
@ -16,7 +16,7 @@ System UI host. Renders one WebView pointing at `system-ui.html` using the embed
|
|||
|
||||
### 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
|
||||
|
||||
|
|
|
|||
|
|
@ -30,7 +30,9 @@ For verified read-only package storage, `weft-pack build-image` produces an EROF
|
|||
|
||||
## 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)
|
||||
|
||||
|
|
|
|||
|
|
@ -65,6 +65,11 @@
|
|||
object identity; no separate window_id is exchanged. The
|
||||
compositor will emit configure on the new object to communicate the
|
||||
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>
|
||||
<arg name="id" type="new_id" interface="zweft_shell_window_v1"
|
||||
summary="new window object"/>
|
||||
|
|
@ -114,6 +119,8 @@
|
|||
<description summary="protocol errors"/>
|
||||
<entry name="defunct_window" value="0"
|
||||
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>
|
||||
|
||||
<request name="destroy" type="destructor">
|
||||
|
|
|
|||
|
|
@ -169,9 +169,16 @@ def run(args, desktop, xdotool):
|
|||
appd = AppdClient(port, token)
|
||||
appd.send({"type": "LAUNCH_APP", "app_id": APP_ID, "surface_id": 0})
|
||||
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:
|
||||
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():
|
||||
deadline = time.monotonic() + 10
|
||||
|
|
@ -213,6 +220,15 @@ def run(args, desktop, xdotool):
|
|||
if states[3] != states[1]:
|
||||
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):
|
||||
import subprocess
|
||||
|
|
|
|||
Loading…
Reference in a new issue