fix(deps): backport secure Wayland XML parser

2026-07-10 00:37:49 -04:00
parent fcc8443c45
commit 670f7abe60
24 changed files with 6886 additions and 5 deletions
@@ -0,0 +1,298 @@
+use proc_macro2::{Ident, Span, TokenStream};
+
+use quote::{format_ident, quote};
+
+use crate::{
+    protocol::{Interface, Protocol, Type},
+    util::{description_to_doc_attr, dotted_to_relname, is_keyword, snake_to_camel, to_doc_attr},
+    Side,
+};
+
+pub fn generate_server_objects(protocol: &Protocol) -> TokenStream {
+    protocol
+        .interfaces
+        .iter()
+        .filter(|iface| iface.name != "wl_display")
+        .map(generate_objects_for)
+        .collect()
+}
+
+fn generate_objects_for(interface: &Interface) -> TokenStream {
+    let mod_name = Ident::new(&interface.name, Span::call_site());
+    let mod_doc = interface.description.as_ref().map(description_to_doc_attr);
+    let iface_name = Ident::new(&snake_to_camel(&interface.name), Span::call_site());
+    let iface_const_name = format_ident!("{}_INTERFACE", interface.name.to_ascii_uppercase());
+
+    let enums = crate::common::generate_enums_for(interface);
+    let msg_constants = crate::common::gen_msg_constants(&interface.requests, &interface.events);
+
+    let requests = crate::common::gen_message_enum(
+        &format_ident!("Request"),
+        Side::Server,
+        true,
+        &interface.requests,
+    );
+    let events = crate::common::gen_message_enum(
+        &format_ident!("Event"),
+        Side::Server,
+        false,
+        &interface.events,
+    );
+
+    let parse_body = if interface.name == "wl_registry" {
+        quote! { unimplemented!("`wl_registry` is implemented internally in `wayland-server`") }
+    } else {
+        crate::message_io::gen_parse_body(interface, Side::Server)
+    };
+    let write_body = crate::message_io::gen_write_body(interface, Side::Server);
+    let methods = gen_methods(interface);
+
+    let event_ref = if interface.requests.is_empty() {
+        "This interface has no requests."
+    } else {
+        "See also the [Request] enum for this interface."
+    };
+    let docs = match &interface.description {
+        Some((short, long)) => format!("{short}\n\n{long}\n\n{event_ref}"),
+        None => format!("{}\n\n{}", interface.name, event_ref),
+    };
+    let doc_attr = to_doc_attr(&docs);
+
+    quote! {
+        #mod_doc
+        pub mod #mod_name {
+            use std::sync::Arc;
+            use std::os::unix::io::OwnedFd;
+
+            use super::wayland_server::{
+                backend::{
+                    smallvec, ObjectData, ObjectId, InvalidId, WeakHandle,
+                    protocol::{WEnum, Argument, Message, Interface, same_interface}
+                },
+                Resource, Dispatch, DisplayHandle, DispatchError, ResourceData, New, Weak,
+            };
+
+            #enums
+            #msg_constants
+            #requests
+            #events
+
+            #doc_attr
+            #[derive(Debug, Clone)]
+            pub struct #iface_name {
+                id: ObjectId,
+                version: u32,
+                data: Option<Arc<dyn std::any::Any + Send + Sync + 'static>>,
+                handle: WeakHandle,
+            }
+
+            impl std::cmp::PartialEq for #iface_name {
+                #[inline]
+                fn eq(&self, other: &#iface_name) -> bool {
+                    self.id == other.id
+                }
+            }
+
+            impl std::cmp::Eq for #iface_name {}
+
+            impl PartialEq<Weak<#iface_name>> for #iface_name {
+                #[inline]
+                fn eq(&self, other: &Weak<#iface_name>) -> bool {
+                    self.id == other.id()
+                }
+            }
+
+            impl std::borrow::Borrow<ObjectId> for #iface_name {
+                #[inline]
+                fn borrow(&self) -> &ObjectId {
+                    &self.id
+                }
+            }
+
+            impl std::hash::Hash for #iface_name {
+                #[inline]
+                fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
+                    self.id.hash(state)
+                }
+            }
+
+            impl super::wayland_server::Resource for #iface_name {
+                type Request = Request;
+                type Event<'event> = Event<'event>;
+
+                #[inline]
+                fn interface() -> &'static Interface{
+                    &super::#iface_const_name
+                }
+
+                #[inline]
+                fn id(&self) -> ObjectId {
+                    self.id.clone()
+                }
+
+                #[inline]
+                fn version(&self) -> u32 {
+                    self.version
+                }
+
+                #[inline]
+                fn data<U: 'static>(&self) -> Option<&U> {
+                    self.data.as_ref().and_then(|arc| (&**arc).downcast_ref::<ResourceData<Self, U>>()).map(|data| &data.udata)
+                }
+
+                #[inline]
+                fn object_data(&self) -> Option<&Arc<dyn std::any::Any + Send + Sync>> {
+                    self.data.as_ref()
+                }
+
+                fn handle(&self) -> &WeakHandle {
+                    &self.handle
+                }
+
+                #[inline]
+                fn from_id(conn: &DisplayHandle, id: ObjectId) -> Result<Self, InvalidId> {
+                    if !same_interface(id.interface(), Self::interface()) && !id.is_null(){
+                        return Err(InvalidId)
+                    }
+                    let version = conn.object_info(id.clone()).map(|info| info.version).unwrap_or(0);
+                    let data = conn.get_object_data(id.clone()).ok();
+                    Ok(#iface_name { id, data, version, handle: conn.backend_handle().downgrade() })
+                }
+
+                fn send_event(&self, evt: Self::Event<'_>) -> Result<(), InvalidId> {
+                    let handle = DisplayHandle::from(self.handle.upgrade().ok_or(InvalidId)?);
+                    handle.send_event(self, evt)
+                }
+
+                fn parse_request(conn: &DisplayHandle, msg: Message<ObjectId, OwnedFd>) -> Result<(Self, Self::Request), DispatchError> {
+                    #parse_body
+                }
+
+                fn write_event<'a>(&self, conn: &DisplayHandle, msg: Self::Event<'a>) -> Result<Message<ObjectId, std::os::unix::io::BorrowedFd<'a>>, InvalidId> {
+                    #write_body
+                }
+
+                fn __set_object_data(&mut self, odata: std::sync::Arc<dyn std::any::Any + Send + Sync + 'static>) {
+                    self.data = Some(odata);
+                }
+            }
+
+            impl #iface_name {
+                #methods
+            }
+        }
+    }
+}
+
+fn gen_methods(interface: &Interface) -> TokenStream {
+    interface
+        .events
+        .iter()
+        .map(|request| {
+            let method_name = format_ident!(
+                "{}{}",
+                if is_keyword(&request.name) { "_" } else { "" },
+                request.name
+            );
+            let enum_variant = Ident::new(&snake_to_camel(&request.name), Span::call_site());
+
+            let fn_args = request.args.iter().flat_map(|arg| {
+                let arg_name =
+                    format_ident!("{}{}", if is_keyword(&arg.name) { "_" } else { "" }, arg.name);
+
+                let arg_type = if let Some(ref enu) = arg.enum_ {
+                    let enum_type = dotted_to_relname(enu);
+                    quote! { #enum_type }
+                } else {
+                    match arg.typ {
+                        Type::Uint => quote! { u32 },
+                        Type::Int => quote! { i32 },
+                        Type::Fixed => quote! { f64 },
+                        Type::String => {
+                            if arg.allow_null {
+                                quote! { Option<String> }
+                            } else {
+                                quote! { String }
+                            }
+                        }
+                        Type::Array => {
+                            if arg.allow_null {
+                                quote! { Option<Vec<u8>> }
+                            } else {
+                                quote! { Vec<u8> }
+                            }
+                        }
+                        Type::Fd => quote! { ::std::os::unix::io::BorrowedFd<'_> },
+                        Type::Object | Type::NewId => {
+                            let iface = arg.interface.as_ref().unwrap();
+                            let iface_mod = Ident::new(iface, Span::call_site());
+                            let iface_type = Ident::new(&snake_to_camel(iface), Span::call_site());
+                            if arg.allow_null {
+                                quote! { Option<&super::#iface_mod::#iface_type> }
+                            } else {
+                                quote! { &super::#iface_mod::#iface_type }
+                            }
+                        }
+                        Type::Destructor => panic!("An argument cannot have type \"destructor\"."),
+                    }
+                };
+
+                Some(quote! {
+                    #arg_name: #arg_type
+                })
+            });
+
+            let enum_args = request.args.iter().flat_map(|arg| {
+                let arg_name =
+                    format_ident!("{}{}", if is_keyword(&arg.name) { "_" } else { "" }, arg.name);
+                if arg.enum_.is_some() {
+                    Some(quote! { #arg_name: WEnum::Value(#arg_name) })
+                } else if arg.typ == Type::Object || arg.typ == Type::NewId {
+                    if arg.allow_null {
+                        Some(quote! { #arg_name: #arg_name.cloned() })
+                    } else {
+                        Some(quote! { #arg_name: #arg_name.clone() })
+                    }
+                } else {
+                    Some(quote! { #arg_name })
+                }
+            });
+
+            let doc_attr = request.description.as_ref().map(description_to_doc_attr);
+
+            quote! {
+                #doc_attr
+                #[allow(clippy::too_many_arguments)]
+                pub fn #method_name(&self, #(#fn_args),*) {
+                    let _ = self.send_event(
+                        Event::#enum_variant {
+                            #(#enum_args),*
+                        }
+                    );
+                }
+            }
+        })
+        .collect()
+}
+
+#[cfg(test)]
+mod tests {
+    #[test]
+    fn server_gen() {
+        let protocol_file =
+            std::fs::File::open("./tests/scanner_assets/test-protocol.xml").unwrap();
+        let protocol_parsed = crate::parse::parse(protocol_file);
+        let generated: String = super::generate_server_objects(&protocol_parsed).to_string();
+        let generated = crate::format_rust_code(&generated);
+
+        let reference =
+            std::fs::read_to_string("./tests/scanner_assets/test-server-code.rs").unwrap();
+        let reference = crate::format_rust_code(&reference);
+
+        if reference != generated {
+            let diff = similar::TextDiff::from_lines(&reference, &generated);
+            print!("{}", diff.unified_diff().context_radius(10).header("reference", "generated"));
+            panic!("Generated does not match reference!")
+        }
+    }
+}