| //! Connection base / building block. |
| //! |
| //! Contains some helper structs and traits common to all Connection types.- |
| |
| use crate::{Message, to_c_str, c_str_to_slice, MessageType}; |
| use crate::message::MatchRule; |
| |
| #[cfg(not(feature = "native-channel"))] |
| mod ffichannel; |
| #[cfg(not(feature = "native-channel"))] |
| pub use ffichannel::Channel; |
| |
| #[cfg(feature = "native-channel")] |
| mod nativechannel; |
| #[cfg(feature = "native-channel")] |
| pub use nativechannel::Channel; |
| |
| |
| /// Which bus to connect to |
| #[derive(Debug, Clone, Copy, PartialOrd, Ord, PartialEq, Eq, Hash)] |
| pub enum BusType { |
| /// The Session bus - local to every logged in session |
| Session = ffi::DBusBusType::Session as isize, |
| /// The system wide bus |
| System = ffi::DBusBusType::System as isize, |
| /// The bus that started us, if any |
| Starter = ffi::DBusBusType::Starter as isize, |
| } |
| |
| /// Platform-specific file descriptor type |
| #[cfg(unix)] |
| pub type WatchFd = std::os::unix::io::RawFd; |
| |
| /// Platform-specific file descriptor type |
| #[cfg(windows)] |
| pub type WatchFd = std::os::windows::io::RawSocket; |
| |
| #[derive(Clone, Copy, Debug, PartialEq, Eq, PartialOrd, Ord)] |
| /// A file descriptor, and an indication whether it should be read from, written to, or both. |
| pub struct Watch { |
| /// File descriptor |
| pub fd: WatchFd, |
| /// True if wakeup should happen when the file descriptor is ready for reading |
| pub read: bool, |
| /// True if wakeup should happen when the file descriptor is ready for writing |
| pub write: bool, |
| } |
| |
| /// Abstraction over different connections that send data |
| pub trait Sender { |
| /// Schedules a message for sending. |
| /// |
| /// Returns a serial number than can be used to match against a reply. |
| fn send(&self, msg: Message) -> Result<u32, ()>; |
| } |
| |
| /// Use in case you don't want the send the message, but just collect it instead. |
| impl Sender for std::cell::RefCell<Vec<Message>> { |
| fn send(&self, msg: Message) -> Result<u32, ()> { |
| self.borrow_mut().push(msg); |
| Ok(0) |
| } |
| } |
| |
| /// Use in case you don't want the send the message, but just collect it instead. |
| impl Sender for std::sync::Mutex<Vec<Message>> { |
| fn send(&self, msg: Message) -> Result<u32, ()> { |
| self.lock().unwrap().push(msg); |
| Ok(0) |
| } |
| } |
| |
| /// Token used to identify a callback in the MatchingReceiver trait |
| #[derive(Copy, Clone, Eq, PartialEq, Ord, PartialOrd, Hash)] |
| pub struct Token(pub usize); |
| |
| /// Abstraction over different connections that receive data |
| pub trait MatchingReceiver { |
| /// Type of callback |
| type F; |
| /// Add a callback to be called in case a message matches. |
| /// |
| /// Returns an id that can be used to remove the callback. |
| fn start_receive(&self, m: MatchRule<'static>, f: Self::F) -> Token; |
| /// Remove a previously added callback. |
| fn stop_receive(&self, id: Token) -> Option<(MatchRule<'static>, Self::F)>; |
| } |
| |
| impl Sender for Channel { |
| fn send(&self, msg: Message) -> Result<u32, ()> { Channel::send(self, msg) } |
| } |
| |
| /// Handles what we need to be a good D-Bus citizen. |
| /// |
| /// Call this if you have not handled the message yourself: |
| /// * It handles calls to org.freedesktop.DBus.Peer. |
| /// * For other method calls, it sends an error reply back that the method was unknown. |
| pub fn default_reply(m: &Message) -> Option<Message> { |
| peer(&m).or_else(|| unknown_method(&m)) |
| } |
| |
| /// Replies if this is a call to org.freedesktop.DBus.Peer, otherwise returns None. |
| fn peer(m: &Message) -> Option<Message> { |
| if let Some(intf) = m.interface() { |
| if &*intf != "org.freedesktop.DBus.Peer" { return None; } |
| if let Some(method) = m.member() { |
| if &*method == "Ping" { return Some(m.method_return()) } |
| if &*method == "GetMachineId" { |
| let mut r = m.method_return(); |
| unsafe { |
| let id = ffi::dbus_get_local_machine_id(); |
| if !id.is_null() { |
| r = r.append1(c_str_to_slice(&(id as *const _)).unwrap()); |
| ffi::dbus_free(id as *mut _); |
| return Some(r) |
| } |
| } |
| return Some(m.error(&"org.freedesktop.DBus.Error.Failed".into(), &to_c_str("Failed to retreive UUID"))) |
| } |
| } |
| Some(m.error(&"org.freedesktop.DBus.Error.UnknownMethod".into(), &to_c_str("Method does not exist"))) |
| } else { None } |
| } |
| |
| /// For method calls, it replies that the method was unknown, otherwise returns None. |
| fn unknown_method(m: &Message) -> Option<Message> { |
| if m.msg_type() != MessageType::MethodCall { return None; } |
| // if m.get_no_reply() { return None; } // The reference implementation does not do this? |
| Some(m.error(&"org.freedesktop.DBus.Error.UnknownMethod".into(), &to_c_str("Path, Interface, or Method does not exist"))) |
| } |
| |
| #[test] |
| fn test_channel_send_sync() { |
| fn is_send<T: Send>(_: &T) {} |
| fn is_sync<T: Sync>(_: &T) {} |
| let c = Channel::get_private(BusType::Session).unwrap(); |
| is_send(&c); |
| is_sync(&c); |
| } |
| |
| #[test] |
| fn channel_simple_test() { |
| let mut c = Channel::get_private(BusType::Session).unwrap(); |
| assert!(c.is_connected()); |
| c.set_watch_enabled(true); |
| let fd = c.watch(); |
| println!("{:?}", fd); |
| let m = Message::new_method_call("org.freedesktop.DBus", "/", "org.freedesktop.DBus", "ListNames").unwrap(); |
| let reply = c.send(m).unwrap(); |
| let my_name = c.unique_name().unwrap(); |
| loop { |
| while let Some(mut msg) = c.pop_message() { |
| println!("{:?}", msg); |
| if msg.get_reply_serial() == Some(reply) { |
| let r = msg.as_result().unwrap(); |
| let z: crate::arg::Array<&str, _> = r.get1().unwrap(); |
| for n in z { |
| println!("{}", n); |
| if n == my_name { return; } // Hooray, we found ourselves! |
| } |
| assert!(false); |
| } else if let Some(r) = default_reply(&msg) { |
| c.send(r).unwrap(); |
| } |
| } |
| c.read_write(Some(std::time::Duration::from_millis(100))).unwrap(); |
| } |
| } |
| |
| #[test] |
| fn test_bus_type_is_compatible_with_set() { |
| use std::collections::HashSet; |
| |
| let mut set: HashSet<BusType> = HashSet::new(); |
| set.insert(BusType::Starter); |
| set.insert(BusType::Starter); |
| |
| assert_eq!(set.len(), 1); |
| assert!(!set.contains(&BusType::Session)); |
| assert!(!set.contains(&BusType::System)); |
| assert!(set.contains(&BusType::Starter)); |
| } |
| |
| |
| #[test] |
| fn watchmap() { |
| let mut c = Channel::get_private(BusType::Session).unwrap(); |
| c.set_watch_enabled(true); |
| let w = c.watch(); |
| assert_eq!(w.write, false); |
| assert_eq!(w.read, true); |
| c.set_watch_enabled(false); |
| println!("{:?}", w); |
| c.set_watch_enabled(true); |
| } |
