client: Implement AsFd for Connection and EventQueue

wayland-backend/CHANGELOG.md

@@ -2,6 +2,10 @@
 
 ## Unreleased
 
+#### Additions
+
+- client: Add `Backend::poll_fd` to return fd for polling
+
 ## 0.3.0 -- 2023-09-02
 
 #### Breaking change

wayland-backend/src/client_api.rs

@@ -181,6 +181,12 @@
         self.backend.flush()
     }
 
+    /// Access the Wayland socket FD for polling
+    #[inline]
+    pub fn poll_fd(&self) -> BorrowedFd {
+        self.backend.poll_fd()
+    }
+
     /// Get the object ID for the `wl_display`
     #[inline]
     pub fn display_id(&self) -> ObjectId {

wayland-backend/src/rs/client_impl/mod.rs

@@ -191,6 +191,13 @@
         }
         Ok(())
     }
+
+    pub fn poll_fd(&self) -> BorrowedFd {
+        let raw_fd = self.state.lock_protocol().socket.as_raw_fd();
+        // This allows the lifetime of the BorrowedFd to be tied to &self rather than the lock guard,
+        // which is the real safety concern
+        unsafe { BorrowedFd::borrow_raw(raw_fd) }
+    }
 }
 
 #[derive(Debug)]

wayland-backend/src/sys/client_impl/mod.rs

@@ -293,6 +293,17 @@
         }
     }
 
+    pub fn poll_fd(&self) -> BorrowedFd {
+        let guard = self.lock_state();
+        unsafe {
+            BorrowedFd::borrow_raw(ffi_dispatch!(
+                wayland_client_handle(),
+                wl_display_get_fd,
+                guard.display
+            ))
+        }
+    }
+
     pub fn dispatch_inner_queue(&self) -> Result<usize, WaylandError> {
         self.inner.dispatch_lock.lock().unwrap().dispatch_pending(self.inner.clone())
     }

wayland-client/CHANGELOG.md

@@ -2,6 +2,11 @@
 
 ## Unreleased
 
+#### Additions
+
+- Implement `AsFd` for `Connection` and `EventQueue` so they can easily be used in a
+  `calloop` source.
+
 ## 0.31.0 -- 2023-09-02
 
 #### Breaking changes

wayland-client/src/conn.rs

@@ -3,7 +3,7 @@
     io::ErrorKind,
     os::unix::io::OwnedFd,
     os::unix::net::UnixStream,
-    os::unix::prelude::{AsRawFd, FromRawFd},
+    os::unix::prelude::{AsFd, AsRawFd, BorrowedFd, FromRawFd},
     path::PathBuf,
     sync::{
         atomic::{AtomicBool, Ordering},
@@ -273,6 +273,13 @@
     }
 }
 
+impl AsFd for Connection {
+    /// Provides fd from [`Backend::poll_fd`] for polling.
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.backend.poll_fd()
+    }
+}
+
 /*
     wl_callback object data for wl_display.sync
 */

wayland-client/src/event_queue.rs

@@ -2,7 +2,7 @@
 use std::collections::VecDeque;
 use std::convert::Infallible;
 use std::marker::PhantomData;
-use std::os::unix::io::OwnedFd;
+use std::os::unix::io::{AsFd, BorrowedFd, OwnedFd};
 use std::sync::{atomic::Ordering, Arc, Condvar, Mutex};
 use std::task;
 
@@ -31,14 +31,14 @@
 ///
 /// In the rare case of an interface with *events* creating new objects (in the core protocol, the only
 /// instance of this is the `wl_data_device.data_offer` event), you'll need to implement the
 /// [`Dispatch::event_created_child()`] method. See the [`event_created_child!`](event_created_child!) macro
 /// for a simple way to do this.
 ///
 /// ## Modularity
 ///
 /// To provide generic handlers for downstream usage, it is possible to make an implementation of the trait
 /// that is generic over the last type argument, as illustrated below. Users will then be able to
 /// automatically delegate their implementation to yours using the [`delegate_dispatch!`] macro.
 ///
 /// As a result, when your implementation is instanciated, the last type parameter `State` will be the state
 /// struct of the app using your generic implementation. You can put additional trait constraints on it to
@@ -118,7 +118,7 @@
     /// Method used to initialize the user-data of objects created by events
     ///
     /// If the interface does not have any such event, you can ignore it. If not, the
     /// [`event_created_child!`](event_created_child!) macro is provided for overriding it.
     #[cfg_attr(coverage, coverage(off))]
     fn event_created_child(opcode: u16, _qhandle: &QueueHandle<State>) -> Arc<dyn ObjectData> {
         panic!(
@@ -349,6 +349,13 @@
     }
 }
 
+impl<State> AsFd for EventQueue<State> {
+    /// Provides fd from [`Backend::poll_fd`] for polling.
+    fn as_fd(&self) -> BorrowedFd<'_> {
+        self.conn.as_fd()
+    }
+}
+
 impl<State> EventQueue<State> {
     pub(crate) fn new(conn: Connection) -> Self {
         let inner = Arc::new(Mutex::new(EventQueueInner {