1use std::{
2 fs::File,
3 io::{ErrorKind, Write},
4 os::fd::{AsRawFd, BorrowedFd, OwnedFd},
5};
6
7use calloop::{LoopHandle, PostAction};
8use filedescriptor::Pipe;
9use wayland_client::{protocol::wl_data_offer::WlDataOffer, Connection};
10use wayland_protocols::wp::primary_selection::zv1::client::zwp_primary_selection_offer_v1::ZwpPrimarySelectionOfferV1;
11
12use crate::{platform::linux::platform::read_fd, ClipboardItem, WaylandClientStatePtr};
13
14pub(crate) const TEXT_MIME_TYPE: &str = "text/plain;charset=utf-8";
15pub(crate) const FILE_LIST_MIME_TYPE: &str = "text/uri-list";
16
17/// Text mime types that we'll accept from other programs.
18pub(crate) const ALLOWED_TEXT_MIME_TYPES: [&str; 2] = ["text/plain;charset=utf-8", "UTF8_STRING"];
19
20pub(crate) struct Clipboard {
21 connection: Connection,
22 loop_handle: LoopHandle<'static, WaylandClientStatePtr>,
23 self_mime: String,
24
25 // Internal clipboard
26 contents: Option<ClipboardItem>,
27 primary_contents: Option<ClipboardItem>,
28
29 // External clipboard
30 cached_read: Option<ClipboardItem>,
31 current_offer: Option<DataOffer<WlDataOffer>>,
32 cached_primary_read: Option<ClipboardItem>,
33 current_primary_offer: Option<DataOffer<ZwpPrimarySelectionOfferV1>>,
34}
35
36#[derive(Clone, Debug)]
37/// Wrapper for `WlDataOffer` and `ZwpPrimarySelectionOfferV1`, used to help track mime types.
38pub(crate) struct DataOffer<T> {
39 pub inner: T,
40 mime_types: Vec<String>,
41}
42
43impl<T> DataOffer<T> {
44 pub fn new(offer: T) -> Self {
45 Self {
46 inner: offer,
47 mime_types: Vec::new(),
48 }
49 }
50
51 pub fn add_mime_type(&mut self, mime_type: String) {
52 self.mime_types.push(mime_type)
53 }
54
55 pub fn has_mime_type(&self, mime_type: &str) -> bool {
56 self.mime_types.iter().any(|t| t == mime_type)
57 }
58
59 pub fn find_text_mime_type(&self) -> Option<String> {
60 for offered_mime_type in &self.mime_types {
61 if let Some(offer_text_mime_type) = ALLOWED_TEXT_MIME_TYPES
62 .into_iter()
63 .find(|text_mime_type| text_mime_type == offered_mime_type)
64 {
65 return Some(offer_text_mime_type.to_owned());
66 }
67 }
68 None
69 }
70}
71
72impl Clipboard {
73 pub fn new(
74 connection: Connection,
75 loop_handle: LoopHandle<'static, WaylandClientStatePtr>,
76 ) -> Self {
77 Self {
78 connection,
79 loop_handle,
80 self_mime: format!("pid/{}", std::process::id()),
81
82 contents: None,
83 primary_contents: None,
84
85 cached_read: None,
86 current_offer: None,
87 cached_primary_read: None,
88 current_primary_offer: None,
89 }
90 }
91
92 pub fn set(&mut self, item: ClipboardItem) {
93 self.contents = Some(item);
94 }
95
96 pub fn set_primary(&mut self, item: ClipboardItem) {
97 self.primary_contents = Some(item);
98 }
99
100 pub fn set_offer(&mut self, data_offer: Option<DataOffer<WlDataOffer>>) {
101 self.cached_read = None;
102 self.current_offer = data_offer;
103 }
104
105 pub fn set_primary_offer(&mut self, data_offer: Option<DataOffer<ZwpPrimarySelectionOfferV1>>) {
106 self.cached_primary_read = None;
107 self.current_primary_offer = data_offer;
108 }
109
110 pub fn self_mime(&self) -> String {
111 self.self_mime.clone()
112 }
113
114 pub fn send(&self, _mime_type: String, fd: OwnedFd) {
115 if let Some(contents) = &self.contents {
116 self.send_internal(fd, contents.text.as_bytes().to_owned());
117 }
118 }
119
120 pub fn send_primary(&self, _mime_type: String, fd: OwnedFd) {
121 if let Some(primary_contents) = &self.primary_contents {
122 self.send_internal(fd, primary_contents.text.as_bytes().to_owned());
123 }
124 }
125
126 pub fn read(&mut self) -> Option<ClipboardItem> {
127 let offer = self.current_offer.clone()?;
128 if let Some(cached) = self.cached_read.clone() {
129 return Some(cached);
130 }
131
132 if offer.has_mime_type(&self.self_mime) {
133 return self.contents.clone();
134 }
135
136 let mime_type = offer.find_text_mime_type()?;
137 let pipe = Pipe::new().unwrap();
138 offer.inner.receive(mime_type, unsafe {
139 BorrowedFd::borrow_raw(pipe.write.as_raw_fd())
140 });
141 let fd = pipe.read;
142 drop(pipe.write);
143
144 self.connection.flush().unwrap();
145
146 match unsafe { read_fd(fd) } {
147 Ok(v) => {
148 self.cached_read = Some(ClipboardItem::new(v));
149 self.cached_read.clone()
150 }
151 Err(err) => {
152 log::error!("error reading clipboard pipe: {err:?}");
153 None
154 }
155 }
156 }
157
158 pub fn read_primary(&mut self) -> Option<ClipboardItem> {
159 let offer = self.current_primary_offer.clone()?;
160 if let Some(cached) = self.cached_primary_read.clone() {
161 return Some(cached);
162 }
163
164 if offer.has_mime_type(&self.self_mime) {
165 return self.primary_contents.clone();
166 }
167
168 let mime_type = offer.find_text_mime_type()?;
169 let pipe = Pipe::new().unwrap();
170 offer.inner.receive(mime_type, unsafe {
171 BorrowedFd::borrow_raw(pipe.write.as_raw_fd())
172 });
173 let fd = pipe.read;
174 drop(pipe.write);
175
176 self.connection.flush().unwrap();
177
178 match unsafe { read_fd(fd) } {
179 Ok(v) => {
180 self.cached_primary_read = Some(ClipboardItem::new(v.clone()));
181 self.cached_primary_read.clone()
182 }
183 Err(err) => {
184 log::error!("error reading clipboard pipe: {err:?}");
185 None
186 }
187 }
188 }
189
190 fn send_internal(&self, fd: OwnedFd, bytes: Vec<u8>) {
191 let mut written = 0;
192 self.loop_handle
193 .insert_source(
194 calloop::generic::Generic::new(
195 File::from(fd),
196 calloop::Interest::WRITE,
197 calloop::Mode::Level,
198 ),
199 move |_, file, _| {
200 let mut file = unsafe { file.get_mut() };
201 loop {
202 match file.write(&bytes[written..]) {
203 Ok(n) if written + n == bytes.len() => {
204 written += n;
205 break Ok(PostAction::Remove);
206 }
207 Ok(n) => written += n,
208 Err(err) if err.kind() == ErrorKind::WouldBlock => {
209 break Ok(PostAction::Continue)
210 }
211 Err(_) => break Ok(PostAction::Remove),
212 }
213 }
214 },
215 )
216 .unwrap();
217 }
218}