| //! Contains structs and traits closely related to D-Bus messages. |
| |
| use std::{fmt, ptr}; |
| use super::{ffi, Error, libc, init_dbus}; |
| use crate::strings::{BusName, Path, Interface, Member, ErrorName}; |
| use std::ffi::CStr; |
| |
| use super::arg::{Append, AppendAll, IterAppend, ReadAll, Get, Iter, Arg, RefArg, TypeMismatchError}; |
| |
| #[derive(Copy, Clone, Debug, Eq, Ord, PartialEq, PartialOrd, Hash)] |
| /// One of the four different message types. |
| pub enum MessageType { |
| /// This is a method call D-Bus message |
| MethodCall = 1, |
| /// This is a method return Ok D-Bus message, used when the method call message was successfully processed |
| MethodReturn = 2, |
| /// This is a method return with error D-Bus message, used when the method call message could not be handled |
| Error = 3, |
| /// This is a signal, usually sent to whoever wants to listen |
| Signal = 4, |
| } |
| |
| impl<'a> TryFrom<&'a str> for MessageType { |
| type Error = (); |
| |
| fn try_from(value: &'a str) -> Result<Self, <crate::message::MessageType as TryFrom<&'a str>>::Error> { |
| match value { |
| "error" => Ok(MessageType::Error), |
| "method_call" => Ok(MessageType::MethodCall), |
| "method_return" => Ok(MessageType::MethodReturn), |
| "signal" => Ok(MessageType::Signal), |
| _ => Err(()) |
| } |
| } |
| } |
| |
| mod signalargs; |
| pub use self::signalargs::SignalArgs; |
| |
| mod matchrule; |
| pub use self::matchrule::MatchRule; |
| use std::convert::TryFrom; |
| |
| mod parser; |
| pub use self::parser::Error as MatchRuleParserError; |
| |
| /// A D-Bus message. A message contains headers - usually destination address, path, interface and member, |
| /// and a list of arguments. |
| pub struct Message { |
| msg: *mut ffi::DBusMessage, |
| } |
| |
| unsafe impl Send for Message {} |
| |
| impl Message { |
| /// Creates a new method call message. |
| pub fn new_method_call<'d, 'p, 'i, 'm, D, P, I, M>(destination: D, path: P, iface: I, method: M) -> Result<Message, String> |
| where D: Into<BusName<'d>>, P: Into<Path<'p>>, I: Into<Interface<'i>>, M: Into<Member<'m>> { |
| init_dbus(); |
| let (d, p, i, m) = (destination.into(), path.into(), iface.into(), method.into()); |
| let ptr = unsafe { |
| ffi::dbus_message_new_method_call(d.as_ptr(), p.as_ptr(), i.as_ptr(), m.as_ptr()) |
| }; |
| if ptr.is_null() { Err("D-Bus error: dbus_message_new_method_call failed".into()) } |
| else { Ok(Message { msg: ptr}) } |
| } |
| |
| /// Creates a new method call message. |
| pub fn method_call(destination: &BusName, path: &Path, iface: &Interface, name: &Member) -> Message { |
| init_dbus(); |
| let ptr = unsafe { |
| ffi::dbus_message_new_method_call(destination.as_ptr(), path.as_ptr(), |
| iface.as_ptr(), name.as_ptr()) |
| }; |
| if ptr.is_null() { panic!("D-Bus error: dbus_message_new_method_call failed") } |
| Message { msg: ptr} |
| } |
| |
| /// Creates a new message that is a replica of this message, but without a serial. |
| /// |
| /// May fail if out of memory or file descriptors. |
| pub fn duplicate(&self) -> Result<Self, String> { |
| let ptr = unsafe { |
| ffi::dbus_message_copy(self.msg) |
| }; |
| if ptr.is_null() { |
| Err("D-Bus error: dbus_message_copy failed".into()) |
| } else { |
| Ok(Message { msg: ptr }) |
| } |
| } |
| |
| /// Creates a new method call message. |
| pub fn call_with_args<'d, 'p, 'i, 'm, A, D, P, I, M>(destination: D, path: P, iface: I, method: M, args: A) -> Message |
| where D: Into<BusName<'d>>, P: Into<Path<'p>>, I: Into<Interface<'i>>, M: Into<Member<'m>>, A: AppendAll { |
| let mut msg = Message::method_call(&destination.into(), &path.into(), &iface.into(), &method.into()); |
| msg.append_all(args); |
| msg |
| } |
| |
| /// Creates a new signal message. |
| pub fn new_signal<P, I, M>(path: P, iface: I, name: M) -> Result<Message, String> |
| where P: Into<String>, I: Into<String>, M: Into<String> { |
| init_dbus(); |
| |
| let p = Path::new(path)?; |
| let i = Interface::new(iface)?; |
| let m = Member::new(name)?; |
| |
| let ptr = unsafe { |
| ffi::dbus_message_new_signal(p.as_ptr(), i.as_ptr(), m.as_ptr()) |
| }; |
| if ptr.is_null() { Err("D-Bus error: dbus_message_new_signal failed".into()) } |
| else { Ok(Message { msg: ptr}) } |
| } |
| |
| /// Creates a new signal message. |
| pub fn signal(path: &Path, iface: &Interface, name: &Member) -> Message { |
| init_dbus(); |
| let ptr = unsafe { |
| ffi::dbus_message_new_signal(path.as_ptr(), iface.as_ptr(), name.as_ptr()) |
| }; |
| if ptr.is_null() { panic!("D-Bus error: dbus_message_new_signal failed") } |
| Message { msg: ptr} |
| } |
| |
| /// Creates a method reply for this method call. |
| pub fn new_method_return(m: &Message) -> Option<Message> { |
| let ptr = unsafe { ffi::dbus_message_new_method_return(m.msg) }; |
| if ptr.is_null() { None } else { Some(Message { msg: ptr} ) } |
| } |
| |
| /// Creates a method return (reply) for this method call. |
| pub fn method_return(&self) -> Message { |
| let ptr = unsafe { ffi::dbus_message_new_method_return(self.msg) }; |
| if ptr.is_null() { panic!("D-Bus error: dbus_message_new_method_return failed") } |
| Message {msg: ptr} |
| } |
| |
| /// Creates a reply for a method call message. |
| /// |
| /// Panics if called for a message which is not a method call. |
| pub fn return_with_args<A: AppendAll>(&self, args: A) -> Message { |
| let mut m = self.method_return(); |
| m.append_all(args); |
| m |
| } |
| |
| /// Creates a new error reply |
| pub fn error(&self, error_name: &ErrorName, error_message: &CStr) -> Message { |
| let ptr = unsafe { ffi::dbus_message_new_error(self.msg, error_name.as_ptr(), error_message.as_ptr()) }; |
| if ptr.is_null() { panic!("D-Bus error: dbus_message_new_error failed") } |
| Message { msg: ptr} |
| } |
| |
| /// Get the MessageItems that make up the message. |
| /// |
| /// Note: use `iter_init` or `get1`/`get2`/etc instead for faster access to the arguments. |
| /// This method is provided for backwards compatibility. |
| pub fn get_items(&self) -> Vec<crate::arg::messageitem::MessageItem> { |
| let mut i = self.iter_init(); |
| let mut v = vec!(); |
| while let Some(z) = crate::arg::messageitem::MessageItem::get(&mut i) { v.push(z); i.next(); } |
| v |
| } |
| |
| /// Get the D-Bus serial of a message, if one was specified. |
| pub fn get_serial(&self) -> Option<u32> { |
| let x = unsafe { ffi::dbus_message_get_serial(self.msg) }; |
| if x == 0 { None } else { Some(x) } |
| } |
| |
| /// Get the serial of the message this message is a reply to, if present. |
| pub fn get_reply_serial(&self) -> Option<u32> { |
| let s = unsafe { ffi::dbus_message_get_reply_serial(self.msg) }; |
| if s == 0 { None } else { Some(s) } |
| } |
| |
| /// Returns true if the message does not expect a reply. |
| pub fn get_no_reply(&self) -> bool { unsafe { ffi::dbus_message_get_no_reply(self.msg) != 0 } } |
| |
| /// Set whether or not the message expects a reply. |
| /// |
| /// Set to true if you send a method call and do not want a reply. |
| pub fn set_no_reply(&mut self, v: bool) { |
| unsafe { ffi::dbus_message_set_no_reply(self.msg, if v { 1 } else { 0 }) } |
| } |
| |
| /// Returns true if the message can cause a service to be auto-started. |
| pub fn get_auto_start(&self) -> bool { unsafe { ffi::dbus_message_get_auto_start(self.msg) != 0 } } |
| |
| /// Sets whether or not the message can cause a service to be auto-started. |
| /// |
| /// Defaults to true. |
| pub fn set_auto_start(&mut self, v: bool) { |
| unsafe { ffi::dbus_message_set_auto_start(self.msg, if v { 1 } else { 0 }) } |
| } |
| |
| /// Add one or more MessageItems to this Message. |
| /// |
| /// Note: using `append1`, `append2` or `append3` might be faster, especially for large arrays. |
| /// This method is provided for backwards compatibility. |
| pub fn append_items(&mut self, v: &[crate::arg::messageitem::MessageItem]) { |
| let mut ia = IterAppend::new(self); |
| for a in v { a.append_by_ref(&mut ia); } |
| } |
| |
| /// Appends one argument to this message. |
| /// Use in builder style: e g `m.method_return().append1(7i32)` |
| pub fn append1<A: Append>(mut self, a: A) -> Self { |
| { |
| let mut m = IterAppend::new(&mut self); |
| m.append(a); |
| } |
| self |
| } |
| |
| /// Appends two arguments to this message. |
| /// Use in builder style: e g `m.method_return().append2(7i32, 6u8)` |
| pub fn append2<A1: Append, A2: Append>(mut self, a1: A1, a2: A2) -> Self { |
| { |
| let mut m = IterAppend::new(&mut self); |
| m.append(a1); m.append(a2); |
| } |
| self |
| } |
| |
| /// Appends three arguments to this message. |
| /// Use in builder style: e g `m.method_return().append3(7i32, 6u8, true)` |
| pub fn append3<A1: Append, A2: Append, A3: Append>(mut self, a1: A1, a2: A2, a3: A3) -> Self { |
| { |
| let mut m = IterAppend::new(&mut self); |
| m.append(a1); m.append(a2); m.append(a3); |
| } |
| self |
| } |
| |
| /// Appends RefArgs to this message. |
| /// Use in builder style: e g `m.method_return().append_ref(&[7i32, 6u8, true])` |
| pub fn append_ref<A: RefArg>(mut self, r: &[A]) -> Self { |
| { |
| let mut m = IterAppend::new(&mut self); |
| for rr in r { |
| rr.append(&mut m); |
| } |
| } |
| self |
| } |
| |
| /// Appends arguments to a message. |
| pub fn append_all<A: AppendAll>(&mut self, a: A) { |
| let mut m = IterAppend::new(self); |
| a.append(&mut m); |
| } |
| |
| /// Gets the first argument from the message, if that argument is of type G1. |
| /// Returns None if there are not enough arguments, or if types don't match. |
| pub fn get1<'a, G1: Get<'a>>(&'a self) -> Option<G1> { |
| let mut i = Iter::new(&self); |
| i.get() |
| } |
| |
| /// Gets the first two arguments from the message, if those arguments are of type G1 and G2. |
| /// Returns None if there are not enough arguments, or if types don't match. |
| pub fn get2<'a, G1: Get<'a>, G2: Get<'a>>(&'a self) -> (Option<G1>, Option<G2>) { |
| let mut i = Iter::new(&self); |
| let g1 = i.get(); |
| if !i.next() { return (g1, None); } |
| (g1, i.get()) |
| } |
| |
| /// Gets the first three arguments from the message, if those arguments are of type G1, G2 and G3. |
| /// Returns None if there are not enough arguments, or if types don't match. |
| pub fn get3<'a, G1: Get<'a>, G2: Get<'a>, G3: Get<'a>>(&'a self) -> (Option<G1>, Option<G2>, Option<G3>) { |
| let mut i = Iter::new(&self); |
| let g1 = i.get(); |
| if !i.next() { return (g1, None, None) } |
| let g2 = i.get(); |
| if !i.next() { return (g1, g2, None) } |
| (g1, g2, i.get()) |
| } |
| |
| /// Gets the first four arguments from the message, if those arguments are of type G1, G2, G3 and G4. |
| /// Returns None if there are not enough arguments, or if types don't match. |
| pub fn get4<'a, G1: Get<'a>, G2: Get<'a>, G3: Get<'a>, G4: Get<'a>>(&'a self) -> (Option<G1>, Option<G2>, Option<G3>, Option<G4>) { |
| let mut i = Iter::new(&self); |
| let g1 = i.get(); |
| if !i.next() { return (g1, None, None, None) } |
| let g2 = i.get(); |
| if !i.next() { return (g1, g2, None, None) } |
| let g3 = i.get(); |
| if !i.next() { return (g1, g2, g3, None) } |
| (g1, g2, g3, i.get()) |
| } |
| |
| /// Gets the first five arguments from the message, if those arguments are of type G1, G2, G3 and G4. |
| /// Returns None if there are not enough arguments, or if types don't match. |
| /// Note: If you need more than five arguments, use `iter_init` instead. |
| pub fn get5<'a, G1: Get<'a>, G2: Get<'a>, G3: Get<'a>, G4: Get<'a>, G5: Get<'a>>(&'a self) -> (Option<G1>, Option<G2>, Option<G3>, Option<G4>, Option<G5>) { |
| let mut i = Iter::new(&self); |
| let g1 = i.get(); |
| if !i.next() { return (g1, None, None, None, None) } |
| let g2 = i.get(); |
| if !i.next() { return (g1, g2, None, None, None) } |
| let g3 = i.get(); |
| if !i.next() { return (g1, g2, g3, None, None) } |
| let g4 = i.get(); |
| if !i.next() { return (g1, g2, g3, g4, None) } |
| (g1, g2, g3, g4, i.get()) |
| } |
| |
| /// Gets the first argument from the message, if that argument is of type G1. |
| /// |
| /// Returns a TypeMismatchError if there are not enough arguments, or if types don't match. |
| pub fn read1<'a, G1: Arg + Get<'a>>(&'a self) -> Result<G1, TypeMismatchError> { |
| let mut i = Iter::new(&self); |
| i.read() |
| } |
| |
| /// Gets the first two arguments from the message, if those arguments are of type G1 and G2. |
| /// |
| /// Returns a TypeMismatchError if there are not enough arguments, or if types don't match. |
| pub fn read2<'a, G1: Arg + Get<'a>, G2: Arg + Get<'a>>(&'a self) -> Result<(G1, G2), TypeMismatchError> { |
| let mut i = Iter::new(&self); |
| Ok((i.read()?, i.read()?)) |
| } |
| |
| /// Gets the first three arguments from the message, if those arguments are of type G1, G2 and G3. |
| /// |
| /// Returns a TypeMismatchError if there are not enough arguments, or if types don't match. |
| pub fn read3<'a, G1: Arg + Get<'a>, G2: Arg + Get<'a>, G3: Arg + Get<'a>>(&'a self) -> |
| Result<(G1, G2, G3), TypeMismatchError> { |
| let mut i = Iter::new(&self); |
| Ok((i.read()?, i.read()?, i.read()?)) |
| } |
| |
| /// Gets the first four arguments from the message, if those arguments are of type G1, G2, G3 and G4. |
| /// |
| /// Returns a TypeMismatchError if there are not enough arguments, or if types don't match. |
| pub fn read4<'a, G1: Arg + Get<'a>, G2: Arg + Get<'a>, G3: Arg + Get<'a>, G4: Arg + Get<'a>>(&'a self) -> |
| Result<(G1, G2, G3, G4), TypeMismatchError> { |
| let mut i = Iter::new(&self); |
| Ok((i.read()?, i.read()?, i.read()?, i.read()?)) |
| } |
| |
| /// Gets the first five arguments from the message, if those arguments are of type G1, G2, G3, G4 and G5. |
| /// |
| /// Returns a TypeMismatchError if there are not enough arguments, or if types don't match. |
| /// Note: If you need more than five arguments, use `iter_init` instead. |
| pub fn read5<'a, G1: Arg + Get<'a>, G2: Arg + Get<'a>, G3: Arg + Get<'a>, G4: Arg + Get<'a>, G5: Arg + Get<'a>>(&'a self) -> |
| Result<(G1, G2, G3, G4, G5), TypeMismatchError> { |
| let mut i = Iter::new(&self); |
| Ok((i.read()?, i.read()?, i.read()?, i.read()?, i.read()?)) |
| } |
| |
| /// Gets arguments from a message. |
| /// |
| /// If this was an error reply or if types mismatch, an error is returned. |
| pub fn read_all<R: ReadAll>(&self) -> Result<R, Error> { |
| self.set_error_from_msg()?; |
| Ok(R::read(&mut self.iter_init())?) |
| } |
| |
| /// Returns a struct for retreiving the arguments from a message. Supersedes get_items(). |
| pub fn iter_init(&self) -> Iter { Iter::new(&self) } |
| |
| /// Gets the MessageType of the Message. |
| pub fn msg_type(&self) -> MessageType { |
| match unsafe { ffi::dbus_message_get_type(self.msg) } { |
| 1 => MessageType::MethodCall, |
| 2 => MessageType::MethodReturn, |
| 3 => MessageType::Error, |
| 4 => MessageType::Signal, |
| x => panic!("Invalid message type {}", x), |
| } |
| } |
| |
| fn msg_internal_str<'a>(&'a self, c: *const libc::c_char) -> Option<&'a str> { |
| if c.is_null() { return None }; |
| let cc = unsafe { CStr::from_ptr(c) }; |
| std::str::from_utf8(cc.to_bytes_with_nul()).ok() |
| } |
| |
| /// Gets the name of the connection that originated this message. |
| pub fn sender(&self) -> Option<BusName> { |
| self.msg_internal_str(unsafe { ffi::dbus_message_get_sender(self.msg) }) |
| .map(|s| unsafe { BusName::from_slice_unchecked(s) }) |
| } |
| |
| /// Gets the object path this Message is being sent to. |
| pub fn path(&self) -> Option<Path> { |
| self.msg_internal_str(unsafe { ffi::dbus_message_get_path(self.msg) }) |
| .map(|s| unsafe { Path::from_slice_unchecked(s) }) |
| } |
| |
| /// Gets the destination this Message is being sent to. |
| pub fn destination(&self) -> Option<BusName> { |
| self.msg_internal_str(unsafe { ffi::dbus_message_get_destination(self.msg) }) |
| .map(|s| unsafe { BusName::from_slice_unchecked(s) }) |
| } |
| |
| /// Sets the destination of this Message |
| /// |
| /// If dest is none, that means broadcast to all relevant destinations. |
| pub fn set_destination(&mut self, dest: Option<BusName>) { |
| let c_dest = dest.as_ref().map(|d| d.as_cstr().as_ptr()).unwrap_or(ptr::null()); |
| assert!(unsafe { ffi::dbus_message_set_destination(self.msg, c_dest) } != 0); |
| } |
| |
| /// Gets the interface this Message is being sent to. |
| pub fn interface(&self) -> Option<Interface> { |
| self.msg_internal_str(unsafe { ffi::dbus_message_get_interface(self.msg) }) |
| .map(|s| unsafe { Interface::from_slice_unchecked(s) }) |
| } |
| |
| /// Gets the interface member being called. |
| pub fn member(&self) -> Option<Member> { |
| self.msg_internal_str(unsafe { ffi::dbus_message_get_member(self.msg) }) |
| .map(|s| unsafe { Member::from_slice_unchecked(s) }) |
| } |
| |
| /// When the remote end returns an error, the message itself is |
| /// correct but its contents is an error. This method will |
| /// transform such an error to a D-Bus Error or otherwise return |
| /// the original message. |
| pub fn as_result(&mut self) -> Result<&mut Message, Error> { |
| self.set_error_from_msg().map(|_| self) |
| } |
| |
| pub (crate) fn set_error_from_msg(&self) -> Result<(), Error> { |
| let mut e = Error::empty(); |
| if unsafe { ffi::dbus_set_error_from_message(e.get_mut(), self.msg) } != 0 { Err(e) } |
| else { Ok(()) } |
| } |
| |
| pub (crate) fn ptr(&self) -> *mut ffi::DBusMessage { self.msg } |
| |
| pub (crate) fn from_ptr(ptr: *mut ffi::DBusMessage, add_ref: bool) -> Message { |
| if add_ref { |
| unsafe { ffi::dbus_message_ref(ptr) }; |
| } |
| Message { msg: ptr } |
| } |
| |
| /// Sets serial number manually - mostly for internal use |
| /// |
| /// When sending a message, a serial will be automatically assigned, so you don't need to call |
| /// this method. However, it can be very useful in test code that is supposed to handle a method call. |
| /// This way, you can create a method call and handle it without sending it to a real D-Bus instance. |
| pub fn set_serial(&mut self, val: u32) { |
| unsafe { ffi::dbus_message_set_serial(self.msg, val) }; |
| } |
| |
| /// Marshals a message - mostly for internal use |
| /// |
| /// The function f will be called one or more times with bytes to be written somewhere. |
| /// You should call set_serial to manually set a serial number before calling this function |
| pub fn marshal<E, F: FnMut(&[u8]) -> Result<(), E>>(&self, mut f: F) -> Result<(), E> { |
| let mut len = 0; |
| let mut data = ptr::null_mut(); |
| if unsafe { ffi::dbus_message_marshal(self.msg, &mut data, &mut len) } == 0 { |
| panic!("out of memory"); |
| } |
| let s = unsafe { std::slice::from_raw_parts(data as *mut u8 as *const u8, len as usize) }; |
| let r = f(s); |
| unsafe { ffi::dbus_free(data as *mut _) }; |
| r |
| } |
| |
| /// Demarshals a message - mostly for internal use |
| pub fn demarshal(data: &[u8]) -> Result<Self, Error> { |
| let mut e = Error::empty(); |
| let p = unsafe { ffi::dbus_message_demarshal(data.as_ptr() as *const _, data.len() as _, e.get_mut()) }; |
| if p == ptr::null_mut() { |
| Err(e) |
| } else { |
| Ok(Self::from_ptr(p, false)) |
| } |
| } |
| |
| /// Returns the size of the message - mostly for internal use |
| /// |
| /// Returns Err(()) on protocol errors. Make sure you have at least 16 bytes in the buffer |
| /// before calling this method. |
| pub fn demarshal_bytes_needed(data: &[u8]) -> Result<usize, ()> { |
| const MIN_HEADER: usize = 16; |
| if data.len() < MIN_HEADER { return Ok(MIN_HEADER); } |
| let x = unsafe { ffi::dbus_message_demarshal_bytes_needed(data.as_ptr() as *const _, data.len() as _) }; |
| if x < MIN_HEADER as _ { Err(()) } else { Ok(x as usize) } |
| } |
| |
| } |
| |
| impl Drop for Message { |
| fn drop(&mut self) { |
| unsafe { |
| ffi::dbus_message_unref(self.msg); |
| } |
| } |
| } |
| |
| impl fmt::Debug for Message { |
| fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> { |
| let mut x = f.debug_struct("Message"); |
| x.field("Type", &self.msg_type()); |
| // The &&** derefs to a &&str, which implements &dyn Debug |
| if let Some(ref path) = self.path() { x.field("Path", &&**path); } |
| if let Some(ref iface) = self.interface() { x.field("Interface", &&**iface); } |
| if let Some(ref member) = self.member() { x.field("Member", &&**member); } |
| if let Some(ref sender) = self.sender() { x.field("Sender", &&**sender); } |
| if let Some(ref dest) = self.destination() { x.field("Destination", &&**dest); } |
| if let Some(ref serial) = self.get_serial() { x.field("Serial", serial); } |
| if let Some(ref rs) = self.get_reply_serial() { x.field("ReplySerial", rs); } |
| let mut args = vec!(); |
| let mut iter = self.iter_init(); |
| while let Some(a) = iter.get_refarg() { |
| args.push(a); |
| iter.next(); |
| } |
| let args2: &[_] = &args; |
| x.field("Args", &args2); |
| x.finish() |
| } |
| } |
| |
| #[cfg(test)] |
| mod test { |
| use crate::{Message}; |
| use crate::strings::BusName; |
| |
| #[test] |
| fn set_valid_destination() { |
| let mut m = Message::new_method_call("org.test.rust", "/", "org.test.rust", "Test").unwrap(); |
| let d = Some(BusName::new(":1.14").unwrap()); |
| m.set_destination(d); |
| |
| assert!(!m.get_no_reply()); |
| m.set_no_reply(true); |
| assert!(m.get_no_reply()); |
| } |
| |
| #[test] |
| fn marshal() { |
| let mut m = Message::new_method_call("org.freedesktop.DBus", "/org/freedesktop/DBus", "org.freedesktop.DBus", "Hello").unwrap(); |
| m.set_serial(1); |
| let r = m.marshal(|d| { |
| let m2 = Message::demarshal(d).unwrap(); |
| assert_eq!(&*m2.path().unwrap(), "/org/freedesktop/DBus"); |
| Err(45) |
| }); |
| assert_eq!(45, r.unwrap_err()); |
| } |
| } |
