wayland: implement wp-drm-lease-v1

src/ifs/wp_drm_lease_connector_v1.rs

@@ -0,0 +1,93 @@
+use {
+    crate::{
+        backend::ConnectorId as BackendConnectorId,
+        client::{Client, ClientError},
+        ifs::wp_drm_lease_device_v1::WpDrmLeaseDeviceV1,
+        leaks::Tracker,
+        object::{Object, Version},
+        utils::bindings::Bindings,
+        wire::{wp_drm_lease_connector_v1::*, WpDrmLeaseConnectorV1Id},
+    },
+    std::rc::Rc,
+    thiserror::Error,
+};
+
+pub struct WpDrmLeaseConnectorV1 {
+    pub id: WpDrmLeaseConnectorV1Id,
+    pub client: Rc<Client>,
+    pub tracker: Tracker<Self>,
+    pub version: Version,
+    pub device: Rc<WpDrmLeaseDeviceV1>,
+    pub connector_id: BackendConnectorId,
+    pub bindings: Rc<Bindings<Self>>,
+}
+
+impl WpDrmLeaseConnectorV1 {
+    fn detach(&self) {
+        self.bindings.remove(&self.client, self);
+    }
+
+    pub fn send_name(&self, name: &str) {
+        self.client.event(Name {
+            self_id: self.id,
+            name,
+        });
+    }
+
+    #[allow(dead_code)]
+    pub fn send_description(&self, description: &str) {
+        self.client.event(Description {
+            self_id: self.id,
+            description,
+        });
+    }
+
+    pub fn send_connector_id(&self, connector_id: u32) {
+        self.client.event(ConnectorId {
+            self_id: self.id,
+            connector_id,
+        });
+    }
+
+    pub fn send_done(&self) {
+        self.client.event(Done { self_id: self.id });
+    }
+
+    pub fn send_withdrawn(&self) {
+        self.client.event(Withdrawn { self_id: self.id });
+    }
+}
+
+impl WpDrmLeaseConnectorV1RequestHandler for WpDrmLeaseConnectorV1 {
+    type Error = WpDrmLeaseConnectorV1Error;
+
+    fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.detach();
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+object_base! {
+    self = WpDrmLeaseConnectorV1;
+    version = self.version;
+}
+
+impl Object for WpDrmLeaseConnectorV1 {
+    fn break_loops(&self) {
+        self.detach();
+    }
+}
+
+dedicated_add_obj!(
+    WpDrmLeaseConnectorV1,
+    WpDrmLeaseConnectorV1Id,
+    drm_lease_outputs
+);
+
+#[derive(Debug, Error)]
+pub enum WpDrmLeaseConnectorV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(WpDrmLeaseConnectorV1Error, ClientError);

src/ifs/wp_drm_lease_device_v1.rs

@@ -0,0 +1,228 @@
+use {
+    crate::{
+        backend::DrmDeviceId,
+        client::{Client, ClientCaps, ClientError, CAP_DRM_LEASE},
+        globals::{Global, GlobalName},
+        ifs::{
+            wp_drm_lease_connector_v1::WpDrmLeaseConnectorV1,
+            wp_drm_lease_request_v1::WpDrmLeaseRequestV1,
+        },
+        leaks::Tracker,
+        object::{Object, Version},
+        state::OutputData,
+        utils::{bindings::Bindings, errorfmt::ErrorFmt, oserror::OsError},
+        video::drm::{Drm, DrmError},
+        wire::{wp_drm_lease_device_v1::*, WpDrmLeaseDeviceV1Id},
+    },
+    std::{cell::Cell, rc::Rc},
+    thiserror::Error,
+    uapi::{c, OwnedFd},
+};
+
+mod removed_device;
+
+pub struct WpDrmLeaseDeviceV1Global {
+    pub name: GlobalName,
+    pub device: DrmDeviceId,
+    pub bindings: Rc<Bindings<WpDrmLeaseDeviceV1>>,
+}
+
+impl WpDrmLeaseDeviceV1Global {
+    fn bind_(
+        self: Rc<Self>,
+        id: WpDrmLeaseDeviceV1Id,
+        client: &Rc<Client>,
+        version: Version,
+    ) -> Result<(), WpDrmLeaseDeviceV1Error> {
+        let obj = Rc::new(WpDrmLeaseDeviceV1 {
+            id,
+            client: client.clone(),
+            tracker: Default::default(),
+            version,
+            bindings: self.bindings.clone(),
+            device: self.device,
+            destroyed: Cell::new(false),
+        });
+        track!(client, obj);
+        client.add_client_obj(&obj)?;
+        if let Some(dev) = client.state.drm_devs.get(&self.device) {
+            if let Some(node) = &dev.devnode {
+                match reopen_card(node) {
+                    Ok(f) => obj.send_drm_fd(&f),
+                    Err(e) => {
+                        log::error!("Could not open master device: {}", ErrorFmt(e));
+                    }
+                }
+            }
+            for c in dev.connectors.lock().keys() {
+                if let Some(o) = client.state.outputs.get(c) {
+                    if o.monitor_info.non_desktop {
+                        obj.create_connector(&o);
+                    }
+                }
+            }
+        }
+        obj.send_done();
+        self.bindings.add(client, &obj);
+        Ok(())
+    }
+}
+
+global_base!(
+    WpDrmLeaseDeviceV1Global,
+    WpDrmLeaseDeviceV1,
+    WpDrmLeaseDeviceV1Error
+);
+
+simple_add_global!(WpDrmLeaseDeviceV1Global);
+
+impl Global for WpDrmLeaseDeviceV1Global {
+    fn singleton(&self) -> bool {
+        false
+    }
+
+    fn version(&self) -> u32 {
+        1
+    }
+
+    fn break_loops(&self) {
+        self.bindings.clear();
+    }
+
+    fn required_caps(&self) -> ClientCaps {
+        CAP_DRM_LEASE
+    }
+}
+
+pub struct WpDrmLeaseDeviceV1 {
+    pub id: WpDrmLeaseDeviceV1Id,
+    pub client: Rc<Client>,
+    pub tracker: Tracker<Self>,
+    pub version: Version,
+    pub bindings: Rc<Bindings<Self>>,
+    pub device: DrmDeviceId,
+    pub destroyed: Cell<bool>,
+}
+
+impl WpDrmLeaseDeviceV1 {
+    fn detach(&self) {
+        self.destroyed.set(true);
+        self.bindings.remove(&self.client, self);
+    }
+
+    pub fn create_connector(self: &Rc<Self>, output: &Rc<OutputData>) {
+        let id = match self.client.new_id() {
+            Ok(i) => i,
+            Err(e) => {
+                self.client.error(e);
+                return;
+            }
+        };
+        let obj = Rc::new(WpDrmLeaseConnectorV1 {
+            id,
+            client: self.client.clone(),
+            tracker: Default::default(),
+            version: self.version,
+            device: self.clone(),
+            connector_id: output.connector.connector.id(),
+            bindings: output.lease_connectors.clone(),
+        });
+        self.client.add_server_obj(&obj);
+        self.send_connector(&obj);
+        obj.send_name(&output.connector.name);
+        if let Some(id) = output.connector.connector.drm_object_id() {
+            obj.send_connector_id(id.0);
+        }
+        obj.send_done();
+        output.lease_connectors.add(&self.client, &obj);
+    }
+
+    fn send_drm_fd(&self, fd: &Rc<OwnedFd>) {
+        self.client.event(DrmFd {
+            self_id: self.id,
+            fd: fd.clone(),
+        });
+    }
+
+    fn send_connector(&self, c: &Rc<WpDrmLeaseConnectorV1>) {
+        self.client.event(Connector {
+            self_id: self.id,
+            id: c.id,
+        });
+    }
+
+    pub fn send_done(&self) {
+        self.client.event(Done { self_id: self.id });
+    }
+
+    fn send_released(&self) {
+        self.client.event(Released { self_id: self.id });
+    }
+}
+
+impl WpDrmLeaseDeviceV1RequestHandler for WpDrmLeaseDeviceV1 {
+    type Error = WpDrmLeaseDeviceV1Error;
+
+    fn create_lease_request(
+        &self,
+        req: CreateLeaseRequest,
+        _slf: &Rc<Self>,
+    ) -> Result<(), Self::Error> {
+        let obj = Rc::new(WpDrmLeaseRequestV1 {
+            id: req.id,
+            client: self.client.clone(),
+            tracker: Default::default(),
+            version: self.version,
+            device: self.device,
+            connectors: Default::default(),
+        });
+        self.client.add_client_obj(&obj)?;
+        Ok(())
+    }
+
+    fn release(&self, _req: Release, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.detach();
+        self.send_released();
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+object_base! {
+    self = WpDrmLeaseDeviceV1;
+    version = self.version;
+}
+
+impl Object for WpDrmLeaseDeviceV1 {
+    fn break_loops(&self) {
+        self.detach();
+    }
+}
+
+simple_add_obj!(WpDrmLeaseDeviceV1);
+
+#[derive(Debug, Error)]
+pub enum WpDrmLeaseDeviceV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(WpDrmLeaseDeviceV1Error, ClientError);
+
+#[derive(Debug, Error)]
+enum ReopenError {
+    #[error("Could not open the dev node")]
+    OpenNode(#[source] OsError),
+    #[error("Could not drop DRM master")]
+    DropMaster(#[source] DrmError),
+}
+
+fn reopen_card(devnode: &str) -> Result<Rc<OwnedFd>, ReopenError> {
+    let fd = uapi::open(devnode, c::O_RDWR | c::O_CLOEXEC, 0)
+        .map_err(|e| ReopenError::OpenNode(e.into()))?;
+    let fd = Rc::new(fd);
+    let drm = Drm::open_existing(fd.clone());
+    if drm.is_master() {
+        drm.drop_master().map_err(ReopenError::DropMaster)?;
+    }
+    Ok(fd)
+}

src/ifs/wp_drm_lease_device_v1/removed_device.rs

@@ -0,0 +1,80 @@
+use {
+    crate::{
+        backend::DrmDeviceId,
+        client::{Client, ClientCaps, ClientError, CAP_DRM_LEASE},
+        globals::{Global, GlobalName, RemovableWaylandGlobal},
+        ifs::wp_drm_lease_device_v1::{WpDrmLeaseDeviceV1, WpDrmLeaseDeviceV1Global},
+        object::Version,
+        utils::bindings::Bindings,
+        wire::WpDrmLeaseDeviceV1Id,
+    },
+    std::{cell::Cell, rc::Rc},
+    thiserror::Error,
+};
+
+struct RemovedWpDrmLeaseDeviceV1Global {
+    name: GlobalName,
+    bindings: Rc<Bindings<WpDrmLeaseDeviceV1>>,
+}
+
+impl RemovedWpDrmLeaseDeviceV1Global {
+    fn bind_(
+        self: Rc<Self>,
+        id: WpDrmLeaseDeviceV1Id,
+        client: &Rc<Client>,
+        version: Version,
+    ) -> Result<(), RemovedWpDrmLeaseDeviceV1Error> {
+        let dev = Rc::new(WpDrmLeaseDeviceV1 {
+            id,
+            client: client.clone(),
+            tracker: Default::default(),
+            version,
+            bindings: self.bindings.clone(),
+            device: DrmDeviceId::from_raw(0),
+            destroyed: Cell::new(false),
+        });
+        track!(client, dev);
+        client.add_client_obj(&dev)?;
+        dev.send_done();
+        dev.bindings.add(client, &dev);
+        Ok(())
+    }
+}
+
+global_base!(
+    RemovedWpDrmLeaseDeviceV1Global,
+    WpDrmLeaseDeviceV1,
+    RemovedWpDrmLeaseDeviceV1Error
+);
+
+simple_add_global!(RemovedWpDrmLeaseDeviceV1Global);
+
+impl Global for RemovedWpDrmLeaseDeviceV1Global {
+    fn singleton(&self) -> bool {
+        false
+    }
+
+    fn version(&self) -> u32 {
+        1
+    }
+
+    fn required_caps(&self) -> ClientCaps {
+        CAP_DRM_LEASE
+    }
+}
+
+impl RemovableWaylandGlobal for WpDrmLeaseDeviceV1Global {
+    fn create_replacement(&self) -> Rc<dyn Global> {
+        Rc::new(RemovedWpDrmLeaseDeviceV1Global {
+            name: self.name,
+            bindings: Default::default(),
+        })
+    }
+}
+
+#[derive(Debug, Error)]
+pub enum RemovedWpDrmLeaseDeviceV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(RemovedWpDrmLeaseDeviceV1Error, ClientError);

src/ifs/wp_drm_lease_request_v1.rs

@@ -0,0 +1,84 @@
+use {
+    crate::{
+        backend::{ConnectorId, DrmDeviceId},
+        client::{Client, ClientError},
+        ifs::wp_drm_lease_v1::{WpDrmLeaseV1, WpDrmLeaseV1Lessee},
+        leaks::Tracker,
+        object::{Object, Version},
+        utils::copyhashmap::CopyHashMap,
+        wire::{wp_drm_lease_request_v1::*, WpDrmLeaseConnectorV1Id, WpDrmLeaseRequestV1Id},
+    },
+    std::{cell::Cell, rc::Rc},
+    thiserror::Error,
+};
+
+pub struct WpDrmLeaseRequestV1 {
+    pub id: WpDrmLeaseRequestV1Id,
+    pub client: Rc<Client>,
+    pub tracker: Tracker<Self>,
+    pub version: Version,
+    pub device: DrmDeviceId,
+    pub connectors: CopyHashMap<WpDrmLeaseConnectorV1Id, ConnectorId>,
+}
+
+impl WpDrmLeaseRequestV1RequestHandler for WpDrmLeaseRequestV1 {
+    type Error = WpDrmLeaseRequestV1Error;
+
+    fn request_connector(&self, req: RequestConnector, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        let c = self.client.lookup(req.connector)?;
+        if self.device != c.device.device {
+            return Err(WpDrmLeaseRequestV1Error::MismatchedDevice(c.id));
+        }
+        if self.connectors.contains(&c.id) {
+            return Err(WpDrmLeaseRequestV1Error::RepeatedDevice(c.id));
+        }
+        self.connectors.set(c.id, c.connector_id);
+        Ok(())
+    }
+
+    fn submit(&self, req: Submit, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.client.remove_obj(self)?;
+        let obj = Rc::new(WpDrmLeaseV1 {
+            id: req.id,
+            client: self.client.clone(),
+            tracker: Default::default(),
+            version: self.version,
+            finished: Cell::new(false),
+            lease: Default::default(),
+        });
+        self.client.add_client_obj(&obj)?;
+        if self.connectors.is_empty() {
+            return Err(WpDrmLeaseRequestV1Error::EmptyLease);
+        }
+        let Some(dev) = self.client.state.drm_devs.get(&self.device) else {
+            obj.send_finished();
+            return Ok(());
+        };
+        let lessee = Rc::new(WpDrmLeaseV1Lessee { obj });
+        let connectors: Vec<_> = self.connectors.lock().values().copied().collect();
+        dev.dev.clone().create_lease(lessee, &connectors);
+        Ok(())
+    }
+}
+
+object_base! {
+    self = WpDrmLeaseRequestV1;
+    version = self.version;
+}
+
+impl Object for WpDrmLeaseRequestV1 {}
+
+simple_add_obj!(WpDrmLeaseRequestV1);
+
+#[derive(Debug, Error)]
+pub enum WpDrmLeaseRequestV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+    #[error("Connector {0} does not belong to this device")]
+    MismatchedDevice(WpDrmLeaseConnectorV1Id),
+    #[error("Connector {0} is already part of this request")]
+    RepeatedDevice(WpDrmLeaseConnectorV1Id),
+    #[error("Lease request is empty")]
+    EmptyLease,
+}
+efrom!(WpDrmLeaseRequestV1Error, ClientError);

src/ifs/wp_drm_lease_v1.rs

@@ -0,0 +1,92 @@
+use {
+    crate::{
+        backend::{BackendDrmLease, BackendDrmLessee},
+        client::{Client, ClientError},
+        leaks::Tracker,
+        object::{Object, Version},
+        utils::clonecell::CloneCell,
+        wire::{wp_drm_lease_v1::*, WpDrmLeaseV1Id},
+    },
+    std::{cell::Cell, rc::Rc},
+    thiserror::Error,
+    uapi::OwnedFd,
+};
+
+pub struct WpDrmLeaseV1Lessee {
+    pub obj: Rc<WpDrmLeaseV1>,
+}
+
+impl BackendDrmLessee for WpDrmLeaseV1Lessee {
+    fn created(&self, lease: Rc<dyn BackendDrmLease>) {
+        if !self.obj.finished.get() {
+            self.obj.send_lease_fd(lease.fd());
+            self.obj.lease.set(Some(lease));
+        }
+    }
+}
+
+impl Drop for WpDrmLeaseV1Lessee {
+    fn drop(&mut self) {
+        if !self.obj.finished.get() {
+            self.obj.detach();
+            self.obj.send_finished();
+        }
+    }
+}
+
+pub struct WpDrmLeaseV1 {
+    pub id: WpDrmLeaseV1Id,
+    pub client: Rc<Client>,
+    pub tracker: Tracker<Self>,
+    pub version: Version,
+    pub finished: Cell<bool>,
+    pub lease: CloneCell<Option<Rc<dyn BackendDrmLease>>>,
+}
+
+impl WpDrmLeaseV1 {
+    fn detach(&self) {
+        self.finished.set(true);
+        self.lease.take();
+    }
+
+    fn send_lease_fd(&self, fd: &Rc<OwnedFd>) {
+        self.client.event(LeaseFd {
+            self_id: self.id,
+            leased_fd: fd.clone(),
+        });
+    }
+
+    pub fn send_finished(&self) {
+        self.client.event(Finished { self_id: self.id });
+    }
+}
+
+impl WpDrmLeaseV1RequestHandler for WpDrmLeaseV1 {
+    type Error = WpDrmLeaseV1Error;
+
+    fn destroy(&self, _req: Destroy, _slf: &Rc<Self>) -> Result<(), Self::Error> {
+        self.detach();
+        self.client.remove_obj(self)?;
+        Ok(())
+    }
+}
+
+object_base! {
+    self = WpDrmLeaseV1;
+    version = self.version;
+}
+
+impl Object for WpDrmLeaseV1 {
+    fn break_loops(&self) {
+        self.detach();
+    }
+}
+
+simple_add_obj!(WpDrmLeaseV1);
+
+#[derive(Debug, Error)]
+pub enum WpDrmLeaseV1Error {
+    #[error(transparent)]
+    ClientError(Box<ClientError>),
+}
+efrom!(WpDrmLeaseV1Error, ClientError);

src/ifs/wp_security_context_v1.rs

@@ -1,6 +1,6 @@
 use {
     crate::{
-        client::{Client, ClientCaps, ClientError},
+        client::{Client, ClientError, CAPS_DEFAULT_SANDBOXED},
         leaks::Tracker,
         object::{Object, Version},
         wire::{wp_security_context_v1::*, WpSecurityContextV1Id},
@@ -80,7 +80,7 @@ impl WpSecurityContextV1RequestHandler for WpSecurityContextV1 {
     fn commit(&self, _req: Commit, _slf: &Rc<Self>) -> Result<(), Self::Error> {
         self.check_committed()?;
         self.committed.set(true);
-        let caps = ClientCaps::none() & self.client.bounding_caps;
+        let caps = CAPS_DEFAULT_SANDBOXED & self.client.bounding_caps;
         self.client.state.security_context_acceptors.spawn(
             &self.client.state,
             self.sandbox_engine.take(),