waybackend/

lib.rs

//! # Waybackend
//!
//! Welcome. Waybackend is a low-level wayland backend that allows you to do wayland stuff without
//! wrapping everything in `Arc`s.

use rustix::{
    fd::{FromRawFd, OwnedFd},
    net::AddressFamily,
};
use types::ObjectId;

mod wayland;

pub use bitflags;
pub use rustix;
pub mod objman;
pub mod shm;
pub mod types;
pub mod wire;

pub use wire::Error;

/// This struct holds the message builder and the wayland file descriptor
///
/// To create this struct, use the [`connect()`] function.
pub struct Waybackend {
    /// the message builder incrementally builds up wire messages
    pub wire_msg_builder: wire::MessageBuilder,
    /// the wayland file descriptor. You can pass this to `poll` to poll events
    pub wayland_fd: OwnedFd,
}

impl Waybackend {
    #[inline]
    #[must_use]
    fn new(wayland_fd: OwnedFd) -> Self {
        Self {
            wire_msg_builder: wire::MessageBuilder::new(),
            wayland_fd,
        }
    }

    #[inline]
    pub fn flush(&mut self) -> Result<(), wire::Error> {
        self.wire_msg_builder.flush(&self.wayland_fd)
    }
}

use std::{num::NonZeroU32, path::PathBuf};

/// The wayland display global object always has the same id: 1
pub const WL_DISPLAY: types::ObjectId = types::ObjectId::new(NonZeroU32::new(1).unwrap());

#[derive(Debug)]
pub enum ConnectionError {
    InvalidWaylandSocketEnvVar,
    InvalidSocketAddrFamily(rustix::net::AddressFamily),
    GetSocketNameFailed(rustix::io::Errno),
    SocketCreationFailed(rustix::io::Errno),
    ConnectionFailed(rustix::io::Errno),
}

impl std::fmt::Display for ConnectionError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            ConnectionError::InvalidWaylandSocketEnvVar => write!(
                f,
                "WAYLAND_SOCKET environment variable contains a value we failed to parse"
            ),
            ConnectionError::InvalidSocketAddrFamily(actual) => write!(
                f,
                "socket address in WAYLAND_SOCKET is not a unix socket. It's actual address family is: {actual:?}"
            ),
            ConnectionError::GetSocketNameFailed(errno) => {
                write!(f, "failed to get socket name: {errno}")
            }
            ConnectionError::SocketCreationFailed(errno) => {
                write!(f, "failed to create socket: {errno}")
            }
            ConnectionError::ConnectionFailed(errno) => {
                write!(f, "failed to connect to the unix stream: {errno}")
            }
        }
    }
}

impl std::error::Error for ConnectionError {}

/// Mostly copy-pasted from `wayland-client.rs`
///
/// This will connect to the wayland server using several fallback heuristics.
///
/// It first tries the `WAYLAND_SOCKET` environment variable. Failing that, it tries to read the
/// `WAYLAND_DISPLAY` variable. If it isn't set, we default to `wayland-0`.
///
/// Returns a [`Waybackend`] with the wayland file descriptor and wire message builder.
#[inline]
pub fn connect() -> Result<Waybackend, ConnectionError> {
    if let Ok(txt) = std::env::var("WAYLAND_SOCKET") {
        // We should connect to the provided WAYLAND_SOCKET
        let fd = txt
            .parse::<i32>()
            .map_err(|_| ConnectionError::InvalidWaylandSocketEnvVar)?;
        let fd = unsafe { OwnedFd::from_raw_fd(fd) };

        match rustix::net::getsockname(&fd) {
            Ok(socket_addr) => {
                if socket_addr.address_family() == AddressFamily::UNIX {
                    Ok(Waybackend::new(fd))
                } else {
                    Err(ConnectionError::InvalidSocketAddrFamily(
                        socket_addr.address_family(),
                    ))
                }
            }
            Err(e) => Err(ConnectionError::GetSocketNameFailed(e)),
        }
    } else {
        let socket_name: PathBuf = std::env::var_os("WAYLAND_DISPLAY")
            .unwrap_or_else(|| {
                log::warn!("WAYLAND_DISPLAY is not set! Defaulting to wayland-0");
                std::ffi::OsString::from("wayland-0")
            })
            .into();

        let socket_path = if socket_name.is_absolute() {
            socket_name
        } else {
            let mut socket_path: PathBuf = std::env::var_os("XDG_RUNTIME_DIR")
                .unwrap_or_else(|| {
                    log::warn!("XDG_RUNTIME_DIR is not set! Defaulting to /run/user/UID");
                    let uid = rustix::process::getuid();
                    let mut p: PathBuf = ["run", "user"].iter().collect();
                    p.push(format!("{}", uid.as_raw()));
                    p.into_os_string()
                })
                .into();

            socket_path.push(socket_name);
            socket_path
        };

        let unix_addr =
            rustix::net::SocketAddrUnix::new(socket_path.display().to_string().as_str()).unwrap();
        let socket = rustix::net::socket_with(
            rustix::net::AddressFamily::UNIX,
            rustix::net::SocketType::STREAM,
            rustix::net::SocketFlags::CLOEXEC,
            None,
        )
        .map_err(ConnectionError::SocketCreationFailed)?;

        rustix::net::connect(&socket, &unix_addr).map_err(ConnectionError::ConnectionFailed)?;
        Ok(Waybackend::new(socket))
    }
}

#[derive(Debug)]
pub enum RoundtripError {
    WireError(wire::Error),
    WaylandError((ObjectId, u32, String)),
    MessageFromUnknownObject(ObjectId),
    UnexpectedDeleteId(u32),
}

impl std::fmt::Display for RoundtripError {
    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
        match self {
            RoundtripError::WireError(error) => {
                write!(f, "roundtrip failed due to wayland wire error: {error}")
            }
            RoundtripError::MessageFromUnknownObject(id) => {
                write!(f, "received message from unknown object of id: {id}")
            }
            RoundtripError::UnexpectedDeleteId(id) => {
                write!(
                    f,
                    "Received a delete_id message from the display for id: {id}.\n\
                    This should never happen during the roundtrip initialization.\n\
                    This wayland implementation is probably fucked."
                )
            }
            RoundtripError::WaylandError((id, code, msg)) => write!(
                f,
                "Wayland protocol error. Object: {id}. Code: {code}. Message: {msg}"
            ),
        }
    }
}

impl std::error::Error for RoundtripError {}

#[derive(Debug)]
/// A wayland global. Use this to bind the interfaces you want
pub struct Global {
    name: u32,
    interface: String,
    version: u32,
}

impl Global {
    #[inline]
    pub fn name(&self) -> u32 {
        self.name
    }

    #[inline]
    pub fn interface(&self) -> &str {
        &self.interface
    }

    #[inline]
    pub fn version(&self) -> u32 {
        self.version
    }

    #[inline]
    pub fn bind<T: Copy + PartialEq>(
        &self,
        backend: &mut crate::Waybackend,
        registry: ObjectId,
        objman: &mut objman::ObjectManager<T>,
        object: T,
    ) -> Result<(), wire::Error> {
        let id = objman.create(object);
        wayland::wl_registry::req::bind(
            backend,
            registry,
            self.name,
            id,
            &self.interface,
            self.version,
        )
    }
}

struct GlobalHandler {
    globals: Vec<Global>,
    error: Option<RoundtripError>,
    done: bool,
    delete_callback: bool,
}

impl GlobalHandler {
    fn new() -> Self {
        Self {
            globals: Vec::new(),
            error: None,
            done: false,
            delete_callback: false,
        }
    }
}

impl wayland::wl_display::EvHandler for GlobalHandler {
    fn error(&mut self, _: ObjectId, object_id: ObjectId, code: u32, message: &str) {
        self.error = Some(RoundtripError::WaylandError((
            object_id,
            code,
            message.to_string(),
        )));
    }

    fn delete_id(&mut self, _: ObjectId, id: u32) {
        if id != 3 {
            self.error = Some(RoundtripError::UnexpectedDeleteId(id));
        } else {
            self.delete_callback = true;
        }
    }
}

impl wayland::wl_registry::EvHandler for GlobalHandler {
    fn global(&mut self, _: ObjectId, name: u32, interface: &str, version: u32) {
        self.globals.push(Global {
            name,
            interface: interface.to_string(),
            version,
        });
    }

    fn global_remove(&mut self, _: ObjectId, name: u32) {
        self.globals.retain(|g| g.name != name)
    }
}

impl wayland::wl_callback::EvHandler for GlobalHandler {
    fn done(&mut self, _: ObjectId, _: u32) {
        self.done = true;
    }
}

/// Does a roundtrip to gather all the globals during program initialization
///
/// We return: a list of globals and whether or not you should delete the callback with id
/// `callback_id`.
#[inline]
pub fn roundtrip(
    backend: &mut Waybackend,
    receiver: &mut wire::Receiver,
    registry_id: ObjectId,
    callback_id: ObjectId,
) -> Result<(Vec<Global>, bool), RoundtripError> {
    let mut global_handler = GlobalHandler::new();
    wayland::wl_display::req::get_registry(backend, WL_DISPLAY, registry_id)
        .map_err(RoundtripError::WireError)?;
    wayland::wl_display::req::sync(backend, WL_DISPLAY, callback_id)
        .map_err(RoundtripError::WireError)?;
    backend.flush().map_err(RoundtripError::WireError)?;

    while !global_handler.done && global_handler.error.is_none() {
        let mut msg = receiver
            .recv(&backend.wayland_fd)
            .map_err(RoundtripError::WireError)?;
        while msg.has_next().map_err(RoundtripError::WireError)? {
            match msg.sender_id() {
                WL_DISPLAY => wayland::wl_display::event(&mut global_handler, &mut msg)
                    .map_err(RoundtripError::WireError)?,
                id if id == registry_id => {
                    wayland::wl_registry::event(&mut global_handler, &mut msg)
                        .map_err(RoundtripError::WireError)?
                }
                id if id == callback_id => {
                    wayland::wl_callback::event(&mut global_handler, &mut msg)
                        .map_err(RoundtripError::WireError)?
                }
                otherwise => return Err(RoundtripError::MessageFromUnknownObject(otherwise)),
            }
        }
    }

    if let Some(error) = global_handler.error {
        return Err(error);
    }

    Ok((global_handler.globals, global_handler.delete_callback))
}

#[macro_export]
macro_rules! bind_globals {
    (
        $backend:ident,
        $objman:ident,
        $registry:ident,
        $globals:ident,
        $(($interface:ident, $object:path)),*$(,)?
    ) => {
        for global in $globals.iter() {
            match global.interface() {
                $($interface::NAME => global.bind(&mut $backend, $registry, &mut $objman, $object)?),*,
                _ => (),
            }
        }
    }
}