refactor: update wayland crates to latest versions

src/clients/wayland/client.rs

@@ -9,6 +9,7 @@ use color_eyre::Report;
 use smithay_client_toolkit::output::{OutputInfo, OutputState};
 use smithay_client_toolkit::reexports::calloop::channel::{channel, Event, Sender};
 use smithay_client_toolkit::reexports::calloop::EventLoop;
+use smithay_client_toolkit::reexports::calloop_wayland_source::WaylandSource;
 use smithay_client_toolkit::registry::RegistryState;
 use smithay_client_toolkit::seat::SeatState;
 use std::collections::HashMap;
@@ -18,7 +19,7 @@ use tokio::task::spawn_blocking;
 use tracing::{debug, error, trace};
 use wayland_client::globals::registry_queue_init;
 use wayland_client::protocol::wl_seat::WlSeat;
-use wayland_client::{Connection, WaylandSource};
+use wayland_client::Connection;
 
 cfg_if! {
     if #[cfg(feature = "clipboard")] {
@@ -106,8 +107,7 @@ impl WaylandClient {
             let mut event_loop =
                 EventLoop::<Environment>::try_new().expect("Failed to create new event loop");
 
-            WaylandSource::new(queue)
-                .expect("Failed to create Wayland source from queue")
+            WaylandSource::new(conn, queue)
                 .insert(event_loop.handle())
                 .expect("Failed to insert Wayland event queue into event loop");
 

src/clients/wayland/wlr_data_control/mod.rs

@@ -13,7 +13,7 @@ use glib::Bytes;
 use nix::fcntl::{fcntl, F_GETPIPE_SZ, F_SETPIPE_SZ};
 use nix::sys::epoll::{Epoll, EpollCreateFlags, EpollEvent, EpollFlags};
 use smithay_client_toolkit::data_device_manager::WritePipe;
-use smithay_client_toolkit::reexports::calloop::RegistrationToken;
+use smithay_client_toolkit::reexports::calloop::{PostAction, RegistrationToken};
 use std::cmp::min;
 use std::fmt::{Debug, Formatter};
 use std::fs::File;
@@ -195,29 +195,31 @@ impl DataControlDeviceHandler for Environment {
                 let tx = self.clipboard_tx.clone();
                 let clipboard = self.clipboard.clone();
 
-                let token = self
-                    .loop_handle
-                    .insert_source(read_pipe, move |(), file, state| {
-                        let item = state
-                            .selection_offers
-                            .iter()
-                            .position(|o| o.offer == offer_clone)
-                            .map(|p| state.selection_offers.remove(p))
-                            .expect("Failed to find selection offer item");
+                let token =
+                    self.loop_handle
+                        .insert_source(read_pipe, move |(), file, state| unsafe {
+                            let item = state
+                                .selection_offers
+                                .iter()
+                                .position(|o| o.offer == offer_clone)
+                                .map(|p| state.selection_offers.remove(p))
+                                .expect("Failed to find selection offer item");
 
-                        match Self::read_file(&mime_type, file) {
-                            Ok(item) => {
-                                let item = Arc::new(item);
-                                lock!(clipboard).replace(item.clone());
-                                send!(tx, item);
+                            match Self::read_file(&mime_type, file.get_mut()) {
+                                Ok(item) => {
+                                    let item = Arc::new(item);
+                                    lock!(clipboard).replace(item.clone());
+                                    send!(tx, item);
+                                }
+                                Err(err) => error!("{err:?}"),
                             }
-                            Err(err) => error!("{err:?}"),
-                        }
 
-                        state
-                            .loop_handle
-                            .remove(item.token.expect("Missing item token"));
-                    });
+                            state
+                                .loop_handle
+                                .remove(item.token.expect("Missing item token"));
+
+                            PostAction::Remove
+                        });
 
                 match token {
                     Ok(token) => {

src/clients/wayland/wlr_data_control/offer.rs

@@ -5,7 +5,7 @@ use nix::unistd::{close, pipe2};
 use smithay_client_toolkit::data_device_manager::data_offer::DataOfferError;
 use smithay_client_toolkit::data_device_manager::ReadPipe;
 use std::ops::DerefMut;
-use std::os::fd::FromRawFd;
+use std::os::fd::{BorrowedFd, FromRawFd};
 use std::sync::{Arc, Mutex};
 use tracing::{trace, warn};
 use wayland_client::{Connection, Dispatch, Proxy, QueueHandle};
@@ -37,7 +37,7 @@ impl PartialEq for SelectionOffer {
 
 impl SelectionOffer {
     pub fn receive(&self, mime_type: String) -> Result<ReadPipe, DataOfferError> {
-        receive(&self.data_offer, mime_type).map_err(DataOfferError::Io)
+        unsafe { receive(&self.data_offer, mime_type) }.map_err(DataOfferError::Io)
     }
 }
 
@@ -169,15 +169,18 @@ where
 ///
 /// Fails if too many file descriptors were already open and a pipe
 /// could not be created.
-pub fn receive(offer: &ZwlrDataControlOfferV1, mime_type: String) -> std::io::Result<ReadPipe> {
+pub unsafe fn receive(
+    offer: &ZwlrDataControlOfferV1,
+    mime_type: String,
+) -> std::io::Result<ReadPipe> {
     // create a pipe
     let (readfd, writefd) = pipe2(OFlag::O_CLOEXEC)?;
 
-    offer.receive(mime_type, writefd);
+    offer.receive(mime_type, BorrowedFd::borrow_raw(writefd));
 
     if let Err(err) = close(writefd) {
         warn!("Failed to close write pipe: {}", err);
     }
 
-    Ok(unsafe { FromRawFd::from_raw_fd(readfd) })
+    Ok(FromRawFd::from_raw_fd(readfd))
 }