wayland_backend/rs/client_impl/
mod.rs

Help
1//! Client-side rust implementation of a Wayland protocol backend
2
3use std::{
4    fmt,
5    os::unix::{
6        io::{AsRawFd, BorrowedFd, OwnedFd, RawFd},
7        net::UnixStream,
8    },
9    sync::{Arc, Condvar, Mutex, MutexGuard, Weak},
10};
11
12use crate::{
13    core_interfaces::WL_DISPLAY_INTERFACE,
14    debug,
15    protocol::{
16        check_for_signature, same_interface, same_interface_or_anonymous, AllowNull, Argument,
17        ArgumentType, Interface, Message, ObjectInfo, ProtocolError, ANONYMOUS_INTERFACE,
18        INLINE_ARGS,
19    },
20};
21use smallvec::SmallVec;
22
23use super::{
24    client::*,
25    map::{Object, ObjectMap, SERVER_ID_LIMIT},
26    socket::{BufferedSocket, Socket},
27    wire::MessageParseError,
28};
29
30#[derive(Debug, Clone)]
31struct Data {
32    client_destroyed: bool,
33    server_destroyed: bool,
34    user_data: Arc<dyn ObjectData>,
35    serial: u32,
36}
37
38/// An ID representing a Wayland object
39#[derive(Clone)]
40pub struct InnerObjectId {
41    serial: u32,
42    id: u32,
43    interface: &'static Interface,
44}
45
46impl std::cmp::PartialEq for InnerObjectId {
47    fn eq(&self, other: &Self) -> bool {
48        self.id == other.id
49            && self.serial == other.serial
50            && same_interface(self.interface, other.interface)
51    }
52}
53
54impl std::cmp::Eq for InnerObjectId {}
55
56impl std::hash::Hash for InnerObjectId {
57    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
58        self.serial.hash(state);
59        self.id.hash(state);
60    }
61}
62
63impl fmt::Display for InnerObjectId {
64    #[cfg_attr(coverage, coverage(off))]
65    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
66        write!(f, "{}@{}", self.interface.name, self.id)
67    }
68}
69
70impl fmt::Debug for InnerObjectId {
71    #[cfg_attr(coverage, coverage(off))]
72    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
73        write!(f, "ObjectId({}, {})", self, self.serial)
74    }
75}
76
77impl InnerObjectId {
78    pub fn is_null(&self) -> bool {
79        self.id == 0
80    }
81
82    pub fn interface(&self) -> &'static Interface {
83        self.interface
84    }
85
86    pub fn protocol_id(&self) -> u32 {
87        self.id
88    }
89}
90
91#[derive(Debug)]
92struct ProtocolState {
93    socket: BufferedSocket,
94    map: ObjectMap<Data>,
95    last_error: Option<WaylandError>,
96    last_serial: u32,
97    debug: bool,
98}
99
100#[derive(Debug)]
101struct ReadingState {
102    prepared_reads: usize,
103    read_condvar: Arc<Condvar>,
104    read_serial: usize,
105}
106
107#[derive(Debug)]
108pub struct ConnectionState {
109    protocol: Mutex<ProtocolState>,
110    read: Mutex<ReadingState>,
111}
112
113impl ConnectionState {
114    fn lock_protocol(&self) -> MutexGuard<ProtocolState> {
115        self.protocol.lock().unwrap()
116    }
117
118    fn lock_read(&self) -> MutexGuard<ReadingState> {
119        self.read.lock().unwrap()
120    }
121}
122
123#[derive(Clone, Debug)]
124pub struct InnerBackend {
125    state: Arc<ConnectionState>,
126}
127
128#[derive(Clone, Debug)]
129pub struct WeakInnerBackend {
130    state: Weak<ConnectionState>,
131}
132
133impl WeakInnerBackend {
134    pub fn upgrade(&self) -> Option<InnerBackend> {
135        Weak::upgrade(&self.state).map(|state| InnerBackend { state })
136    }
137}
138
139impl PartialEq for InnerBackend {
140    fn eq(&self, rhs: &Self) -> bool {
141        Arc::ptr_eq(&self.state, &rhs.state)
142    }
143}
144
145impl Eq for InnerBackend {}
146
147impl InnerBackend {
148    pub fn downgrade(&self) -> WeakInnerBackend {
149        WeakInnerBackend { state: Arc::downgrade(&self.state) }
150    }
151
152    pub fn connect(stream: UnixStream) -> Result<Self, NoWaylandLib> {
153        let socket = BufferedSocket::new(Socket::from(stream));
154        let mut map = ObjectMap::new();
155        map.insert_at(
156            1,
157            Object {
158                interface: &WL_DISPLAY_INTERFACE,
159                version: 1,
160                data: Data {
161                    client_destroyed: false,
162                    server_destroyed: false,
163                    user_data: Arc::new(DumbObjectData),
164                    serial: 0,
165                },
166            },
167        )
168        .unwrap();
169
170        let debug = debug::has_debug_client_env();
171
172        Ok(Self {
173            state: Arc::new(ConnectionState {
174                protocol: Mutex::new(ProtocolState {
175                    socket,
176                    map,
177                    last_error: None,
178                    last_serial: 0,
179                    debug,
180                }),
181                read: Mutex::new(ReadingState {
182                    prepared_reads: 0,
183                    read_condvar: Arc::new(Condvar::new()),
184                    read_serial: 0,
185                }),
186            }),
187        })
188    }
189
190    /// Flush all pending outgoing requests to the server
191    pub fn flush(&self) -> Result<(), WaylandError> {
192        let mut guard = self.state.lock_protocol();
193        guard.no_last_error()?;
194        if let Err(e) = guard.socket.flush() {
195            return Err(guard.store_if_not_wouldblock_and_return_error(e));
196        }
197        Ok(())
198    }
199
200    pub fn poll_fd(&self) -> BorrowedFd {
201        let raw_fd = self.state.lock_protocol().socket.as_raw_fd();
202        // This allows the lifetime of the BorrowedFd to be tied to &self rather than the lock guard,
203        // which is the real safety concern
204        unsafe { BorrowedFd::borrow_raw(raw_fd) }
205    }
206}
207
208#[derive(Debug)]
209pub struct InnerReadEventsGuard {
210    state: Arc<ConnectionState>,
211    done: bool,
212}
213
214impl InnerReadEventsGuard {
215    /// Create a new reading guard
216    ///
217    /// This call will not block, but event callbacks may be invoked in the process
218    /// of preparing the guard.
219    pub fn try_new(backend: InnerBackend) -> Option<Self> {
220        backend.state.lock_read().prepared_reads += 1;
221        Some(Self { state: backend.state, done: false })
222    }
223
224    /// Access the Wayland socket FD for polling
225    pub fn connection_fd(&self) -> BorrowedFd {
226        let raw_fd = self.state.lock_protocol().socket.as_raw_fd();
227        // This allows the lifetime of the BorrowedFd to be tied to &self rather than the lock guard,
228        // which is the real safety concern
229        unsafe { BorrowedFd::borrow_raw(raw_fd) }
230    }
231
232    /// Attempt to read events from the Wayland socket
233    ///
234    /// If multiple threads have a live reading guard, this method will block until all of them
235    /// are either dropped or have their `read()` method invoked, at which point on of the threads
236    /// will read events from the socket and invoke the callbacks for the received events. All
237    /// threads will then resume their execution.
238    ///
239    /// This returns the number of dispatched events, or `0` if an other thread handled the dispatching.
240    /// If no events are available to read from the socket, this returns a `WouldBlock` IO error.
241    pub fn read(mut self) -> Result<usize, WaylandError> {
242        let mut guard = self.state.lock_read();
243        guard.prepared_reads -= 1;
244        self.done = true;
245        if guard.prepared_reads == 0 {
246            // We should be the one reading
247            let ret = dispatch_events(self.state.clone());
248            // wake up other threads
249            guard.read_serial = guard.read_serial.wrapping_add(1);
250            guard.read_condvar.notify_all();
251            // forward the return value
252            ret
253        } else {
254            // We should wait for an other thread to read (or cancel)
255            let serial = guard.read_serial;
256            let condvar = guard.read_condvar.clone();
257            let _guard =
258                condvar.wait_while(guard, |backend| serial == backend.read_serial).unwrap();
259            self.state.lock_protocol().no_last_error()?;
260            Ok(0)
261        }
262    }
263}
264
265impl Drop for InnerReadEventsGuard {
266    fn drop(&mut self) {
267        if !self.done {
268            let mut guard = self.state.lock_read();
269            guard.prepared_reads -= 1;
270            if guard.prepared_reads == 0 {
271                // Cancel the read
272                guard.read_serial = guard.read_serial.wrapping_add(1);
273                guard.read_condvar.notify_all();
274            }
275        }
276    }
277}
278
279impl InnerBackend {
280    pub fn display_id(&self) -> ObjectId {
281        ObjectId { id: InnerObjectId { serial: 0, id: 1, interface: &WL_DISPLAY_INTERFACE } }
282    }
283
284    pub fn last_error(&self) -> Option<WaylandError> {
285        self.state.lock_protocol().last_error.clone()
286    }
287
288    pub fn info(&self, id: ObjectId) -> Result<ObjectInfo, InvalidId> {
289        let object = self.state.lock_protocol().get_object(id.id.clone())?;
290        if object.data.client_destroyed {
291            Err(InvalidId)
292        } else {
293            Ok(ObjectInfo { id: id.id.id, interface: object.interface, version: object.version })
294        }
295    }
296
297    pub fn null_id() -> ObjectId {
298        ObjectId { id: InnerObjectId { serial: 0, id: 0, interface: &ANONYMOUS_INTERFACE } }
299    }
300
301    pub fn send_request(
302        &self,
303        Message { sender_id: ObjectId { id }, opcode, args }: Message<ObjectId, RawFd>,
304        data: Option<Arc<dyn ObjectData>>,
305        child_spec: Option<(&'static Interface, u32)>,
306    ) -> Result<ObjectId, InvalidId> {
307        let mut guard = self.state.lock_protocol();
308        let object = guard.get_object(id.clone())?;
309
310        let message_desc = match object.interface.requests.get(opcode as usize) {
311            Some(msg) => msg,
312            None => {
313                panic!("Unknown opcode {} for object {}@{}.", opcode, object.interface.name, id.id);
314            }
315        };
316
317        if object.data.client_destroyed {
318            if guard.debug {
319                debug::print_send_message(id.interface.name, id.id, message_desc.name, &args, true);
320            }
321            return Err(InvalidId);
322        }
323
324        if !check_for_signature(message_desc.signature, &args) {
325            panic!(
326                "Unexpected signature for request {}@{}.{}: expected {:?}, got {:?}.",
327                object.interface.name, id.id, message_desc.name, message_desc.signature, args
328            );
329        }
330
331        // Prepare the child object
332        let child_spec = if message_desc
333            .signature
334            .iter()
335            .any(|arg| matches!(arg, ArgumentType::NewId))
336        {
337            if let Some((iface, version)) = child_spec {
338                if let Some(child_interface) = message_desc.child_interface {
339                    if !same_interface(child_interface, iface) {
340                        panic!(
341                            "Error when sending request {}@{}.{}: expected interface {} but got {}",
342                            object.interface.name,
343                            id.id,
344                            message_desc.name,
345                            child_interface.name,
346                            iface.name
347                        );
348                    }
349                    if version != object.version {
350                        panic!(
351                            "Error when sending request {}@{}.{}: expected version {} but got {}",
352                            object.interface.name,
353                            id.id,
354                            message_desc.name,
355                            object.version,
356                            version
357                        );
358                    }
359                }
360                Some((iface, version))
361            } else if let Some(child_interface) = message_desc.child_interface {
362                Some((child_interface, object.version))
363            } else {
364                panic!(
365                    "Error when sending request {}@{}.{}: target interface must be specified for a generic constructor.",
366                    object.interface.name,
367                    id.id,
368                    message_desc.name
369                );
370            }
371        } else {
372            None
373        };
374
375        let child = if let Some((child_interface, child_version)) = child_spec {
376            let child_serial = guard.next_serial();
377
378            let child = Object {
379                interface: child_interface,
380                version: child_version,
381                data: Data {
382                    client_destroyed: false,
383                    server_destroyed: false,
384                    user_data: Arc::new(DumbObjectData),
385                    serial: child_serial,
386                },
387            };
388
389            let child_id = guard.map.client_insert_new(child);
390
391            guard
392                .map
393                .with(child_id, |obj| {
394                    obj.data.user_data = data.expect(
395                        "Sending a request creating an object without providing an object data.",
396                    );
397                })
398                .unwrap();
399            Some((child_id, child_serial, child_interface))
400        } else {
401            None
402        };
403
404        // Prepare the message in a debug-compatible way
405        let args = args.into_iter().map(|arg| {
406            if let Argument::NewId(ObjectId { id: p }) = arg {
407                if p.id != 0 {
408                    panic!("The newid provided when sending request {}@{}.{} is not a placeholder.", object.interface.name, id.id, message_desc.name);
409                }
410                if let Some((child_id, child_serial, child_interface)) = child {
411                    Argument::NewId(ObjectId { id: InnerObjectId { id: child_id, serial: child_serial, interface: child_interface}})
412                } else {
413                    unreachable!();
414                }
415            } else {
416                arg
417            }
418        }).collect::<SmallVec<[_; INLINE_ARGS]>>();
419
420        if guard.debug {
421            debug::print_send_message(
422                object.interface.name,
423                id.id,
424                message_desc.name,
425                &args,
426                false,
427            );
428        }
429        #[cfg(feature = "log")]
430        crate::log_debug!("Sending {}.{} ({})", id, message_desc.name, debug::DisplaySlice(&args));
431
432        // Send the message
433
434        let mut msg_args = SmallVec::with_capacity(args.len());
435        let mut arg_interfaces = message_desc.arg_interfaces.iter();
436        for (i, arg) in args.into_iter().enumerate() {
437            msg_args.push(match arg {
438                Argument::Array(a) => Argument::Array(a),
439                Argument::Int(i) => Argument::Int(i),
440                Argument::Uint(u) => Argument::Uint(u),
441                Argument::Str(s) => Argument::Str(s),
442                Argument::Fixed(f) => Argument::Fixed(f),
443                Argument::NewId(nid) => Argument::NewId(nid.id.id),
444                Argument::Fd(f) => Argument::Fd(f),
445                Argument::Object(o) => {
446                    let next_interface = arg_interfaces.next().unwrap();
447                    if o.id.id != 0 {
448                        let arg_object = guard.get_object(o.id.clone())?;
449                        if !same_interface_or_anonymous(next_interface, arg_object.interface) {
450                            panic!("Request {}@{}.{} expects an argument of interface {} but {} was provided instead.", object.interface.name, id.id, message_desc.name, next_interface.name, arg_object.interface.name);
451                        }
452                    } else if !matches!(message_desc.signature[i], ArgumentType::Object(AllowNull::Yes)) {
453                        panic!("Request {}@{}.{} expects an non-null object argument.", object.interface.name, id.id, message_desc.name);
454                    }
455                    Argument::Object(o.id.id)
456                }
457            });
458        }
459
460        let msg = Message { sender_id: id.id, opcode, args: msg_args };
461
462        if let Err(err) = guard.socket.write_message(&msg) {
463            guard.last_error = Some(WaylandError::Io(err));
464        }
465
466        // Handle destruction if relevant
467        if message_desc.is_destructor {
468            guard
469                .map
470                .with(id.id, |obj| {
471                    obj.data.client_destroyed = true;
472                })
473                .unwrap();
474            object.data.user_data.destroyed(ObjectId { id });
475        }
476        if let Some((child_id, child_serial, child_interface)) = child {
477            Ok(ObjectId {
478                id: InnerObjectId {
479                    id: child_id,
480                    serial: child_serial,
481                    interface: child_interface,
482                },
483            })
484        } else {
485            Ok(Self::null_id())
486        }
487    }
488
489    pub fn get_data(&self, id: ObjectId) -> Result<Arc<dyn ObjectData>, InvalidId> {
490        let object = self.state.lock_protocol().get_object(id.id)?;
491        Ok(object.data.user_data)
492    }
493
494    pub fn set_data(&self, id: ObjectId, data: Arc<dyn ObjectData>) -> Result<(), InvalidId> {
495        self.state
496            .lock_protocol()
497            .map
498            .with(id.id.id, move |objdata| {
499                if objdata.data.serial != id.id.serial {
500                    Err(InvalidId)
501                } else {
502                    objdata.data.user_data = data;
503                    Ok(())
504                }
505            })
506            .unwrap_or(Err(InvalidId))
507    }
508
509    // Nothing to do here, we don't have an inner queue
510    pub fn dispatch_inner_queue(&self) -> Result<usize, WaylandError> {
511        Ok(0)
512    }
513}
514
515impl ProtocolState {
516    fn next_serial(&mut self) -> u32 {
517        self.last_serial = self.last_serial.wrapping_add(1);
518        self.last_serial
519    }
520
521    #[inline]
522    fn no_last_error(&self) -> Result<(), WaylandError> {
523        if let Some(ref err) = self.last_error {
524            Err(err.clone())
525        } else {
526            Ok(())
527        }
528    }
529
530    #[inline]
531    fn store_and_return_error(&mut self, err: impl Into<WaylandError>) -> WaylandError {
532        let err = err.into();
533        crate::log_error!("{}", err);
534        self.last_error = Some(err.clone());
535        err
536    }
537
538    #[inline]
539    fn store_if_not_wouldblock_and_return_error(&mut self, e: std::io::Error) -> WaylandError {
540        if e.kind() != std::io::ErrorKind::WouldBlock {
541            self.store_and_return_error(e)
542        } else {
543            e.into()
544        }
545    }
546
547    fn get_object(&self, id: InnerObjectId) -> Result<Object<Data>, InvalidId> {
548        let object = self.map.find(id.id).ok_or(InvalidId)?;
549        if object.data.serial != id.serial {
550            return Err(InvalidId);
551        }
552        Ok(object)
553    }
554
555    fn handle_display_event(&mut self, message: Message<u32, OwnedFd>) -> Result<(), WaylandError> {
556        if self.debug {
557            debug::print_dispatched_message(
558                "wl_display",
559                message.sender_id,
560                if message.opcode == 0 { "error" } else { "delete_id" },
561                &message.args,
562            );
563        }
564        match message.opcode {
565            0 => {
566                // wl_display.error
567                if let [Argument::Object(obj), Argument::Uint(code), Argument::Str(Some(ref message))] =
568                    message.args[..]
569                {
570                    let object = self.map.find(obj);
571                    let err = WaylandError::Protocol(ProtocolError {
572                        code,
573                        object_id: obj,
574                        object_interface: object
575                            .map(|obj| obj.interface.name)
576                            .unwrap_or("<unknown>")
577                            .into(),
578                        message: message.to_string_lossy().into(),
579                    });
580                    return Err(self.store_and_return_error(err));
581                } else {
582                    unreachable!()
583                }
584            }
585            1 => {
586                // wl_display.delete_id
587                if let [Argument::Uint(id)] = message.args[..] {
588                    let client_destroyed = self
589                        .map
590                        .with(id, |obj| {
591                            obj.data.server_destroyed = true;
592                            obj.data.client_destroyed
593                        })
594                        .unwrap_or(false);
595                    if client_destroyed {
596                        self.map.remove(id);
597                    }
598                } else {
599                    unreachable!()
600                }
601            }
602            _ => unreachable!(),
603        }
604        Ok(())
605    }
606}
607
608fn dispatch_events(state: Arc<ConnectionState>) -> Result<usize, WaylandError> {
609    let backend = Backend { backend: InnerBackend { state } };
610    let mut guard = backend.backend.state.lock_protocol();
611    guard.no_last_error()?;
612    let mut dispatched = 0;
613    loop {
614        // Attempt to read a message
615        let ProtocolState { ref mut socket, ref map, .. } = *guard;
616        let message = match socket.read_one_message(|id, opcode| {
617            map.find(id)
618                .and_then(|o| o.interface.events.get(opcode as usize))
619                .map(|desc| desc.signature)
620        }) {
621            Ok(msg) => msg,
622            Err(MessageParseError::MissingData) | Err(MessageParseError::MissingFD) => {
623                // need to read more data
624                if let Err(e) = guard.socket.fill_incoming_buffers() {
625                    if e.kind() != std::io::ErrorKind::WouldBlock {
626                        return Err(guard.store_and_return_error(e));
627                    } else if dispatched == 0 {
628                        return Err(e.into());
629                    } else {
630                        break;
631                    }
632                }
633                continue;
634            }
635            Err(MessageParseError::Malformed) => {
636                // malformed error, protocol error
637                let err = WaylandError::Protocol(ProtocolError {
638                    code: 0,
639                    object_id: 0,
640                    object_interface: "".into(),
641                    message: "Malformed Wayland message.".into(),
642                });
643                return Err(guard.store_and_return_error(err));
644            }
645        };
646
647        // We got a message, retrieve its associated object & details
648        // These lookups must succeed otherwise we would not have been able to parse this message
649        let receiver = guard.map.find(message.sender_id).unwrap();
650        let message_desc = receiver.interface.events.get(message.opcode as usize).unwrap();
651
652        // Short-circuit display-associated events
653        if message.sender_id == 1 {
654            guard.handle_display_event(message)?;
655            continue;
656        }
657
658        let mut created_id = None;
659
660        // Convert the arguments and create the new object if applicable
661        let mut args = SmallVec::with_capacity(message.args.len());
662        let mut arg_interfaces = message_desc.arg_interfaces.iter();
663        for arg in message.args.into_iter() {
664            args.push(match arg {
665                Argument::Array(a) => Argument::Array(a),
666                Argument::Int(i) => Argument::Int(i),
667                Argument::Uint(u) => Argument::Uint(u),
668                Argument::Str(s) => Argument::Str(s),
669                Argument::Fixed(f) => Argument::Fixed(f),
670                Argument::Fd(f) => Argument::Fd(f),
671                Argument::Object(o) => {
672                    if o != 0 {
673                        // Lookup the object to make the appropriate Id
674                        let obj = match guard.map.find(o) {
675                            Some(o) => o,
676                            None => {
677                                let err = WaylandError::Protocol(ProtocolError {
678                                    code: 0,
679                                    object_id: 0,
680                                    object_interface: "".into(),
681                                    message: format!("Unknown object {}.", o),
682                                });
683                                return Err(guard.store_and_return_error(err));
684                            }
685                        };
686                        if let Some(next_interface) = arg_interfaces.next() {
687                            if !same_interface_or_anonymous(next_interface, obj.interface) {
688                                let err = WaylandError::Protocol(ProtocolError {
689                                    code: 0,
690                                    object_id: 0,
691                                    object_interface: "".into(),
692                                    message: format!(
693                                        "Protocol error: server sent object {} for interface {}, but it has interface {}.",
694                                        o, next_interface.name, obj.interface.name
695                                    ),
696                                });
697                                return Err(guard.store_and_return_error(err));
698                            }
699                        }
700                        Argument::Object(ObjectId { id: InnerObjectId { id: o, serial: obj.data.serial, interface: obj.interface }})
701                    } else {
702                        Argument::Object(ObjectId { id: InnerObjectId { id: 0, serial: 0, interface: &ANONYMOUS_INTERFACE }})
703                    }
704                }
705                Argument::NewId(new_id) => {
706                    // An object should be created
707                    let child_interface = match message_desc.child_interface {
708                        Some(iface) => iface,
709                        None => panic!("Received event {}@{}.{} which creates an object without specifying its interface, this is unsupported.", receiver.interface.name, message.sender_id, message_desc.name),
710                    };
711
712                    let child_udata = Arc::new(UninitObjectData);
713
714                    // if this ID belonged to a now destroyed server object, we can replace it
715                    if new_id >= SERVER_ID_LIMIT
716                        && guard.map.with(new_id, |obj| obj.data.client_destroyed).unwrap_or(false)
717                    {
718                        guard.map.remove(new_id);
719                    }
720
721                    let child_obj = Object {
722                        interface: child_interface,
723                        version: receiver.version,
724                        data: Data {
725                            client_destroyed: receiver.data.client_destroyed,
726                            server_destroyed: false,
727                            user_data: child_udata,
728                            serial: guard.next_serial(),
729                        }
730                    };
731
732                    let child_id = InnerObjectId { id: new_id, serial: child_obj.data.serial, interface: child_obj.interface };
733                    created_id = Some(child_id.clone());
734
735                    if let Err(()) = guard.map.insert_at(new_id, child_obj) {
736                        // abort parsing, this is an unrecoverable error
737                        let err = WaylandError::Protocol(ProtocolError {
738                            code: 0,
739                            object_id: 0,
740                            object_interface: "".into(),
741                            message: format!(
742                                "Protocol error: server tried to create \
743                                an object \"{}\" with invalid id {}.",
744                                child_interface.name, new_id
745                            ),
746                        });
747                        return Err(guard.store_and_return_error(err));
748                    }
749
750                    Argument::NewId(ObjectId { id: child_id })
751                }
752            });
753        }
754
755        if guard.debug {
756            debug::print_dispatched_message(
757                receiver.interface.name,
758                message.sender_id,
759                message_desc.name,
760                &args,
761            );
762        }
763
764        // If this event is send to an already destroyed object (by the client), swallow it
765        if receiver.data.client_destroyed {
766            continue;
767        }
768
769        // Invoke the user callback
770        let id = InnerObjectId {
771            id: message.sender_id,
772            serial: receiver.data.serial,
773            interface: receiver.interface,
774        };
775
776        // unlock the mutex while we invoke the user callback
777        std::mem::drop(guard);
778        #[cfg(feature = "log")]
779        crate::log_debug!(
780            "Dispatching {}.{} ({})",
781            id,
782            receiver.version,
783            debug::DisplaySlice(&args)
784        );
785        let ret = receiver
786            .data
787            .user_data
788            .clone()
789            .event(&backend, Message { sender_id: ObjectId { id }, opcode: message.opcode, args });
790        // lock it again to resume dispatching
791        guard = backend.backend.state.lock_protocol();
792
793        // If this event is a destructor, destroy the object
794        if message_desc.is_destructor {
795            guard
796                .map
797                .with(message.sender_id, |obj| {
798                    obj.data.server_destroyed = true;
799                    obj.data.client_destroyed = true;
800                })
801                .unwrap();
802            receiver.data.user_data.destroyed(ObjectId {
803                id: InnerObjectId {
804                    id: message.sender_id,
805                    serial: receiver.data.serial,
806                    interface: receiver.interface,
807                },
808            });
809        }
810
811        match (created_id, ret) {
812            (Some(child_id), Some(child_data)) => {
813                guard.map.with(child_id.id, |obj| obj.data.user_data = child_data).unwrap();
814            }
815            (None, None) => {}
816            (Some(child_id), None) => {
817                panic!("Callback creating object {} did not provide any object data.", child_id);
818            }
819            (None, Some(_)) => {
820                panic!("An object data was returned from a callback not creating any object");
821            }
822        }
823
824        dispatched += 1;
825    }
826    Ok(dispatched)
827}
wayland_backend/rs/client_impl/mod.rs

wayland_backend/rs/client_impl/
mod.rs
