zbus 1.5.0

API for D-Bus communication
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use crate::{Error, Result};
use async_io::Async;
use nb_connect::unix;
use nix::unistd::Uid;
use polling::{Event, Poller};
use std::{env, ffi::OsString, os::unix::net::UnixStream, str::FromStr};

/// A bus address
#[derive(Debug, PartialEq)]
pub(crate) enum Address {
    /// A path on the filesystem
    Unix(OsString),
}

#[derive(Debug)]
pub(crate) enum Stream {
    Unix(UnixStream),
}

#[derive(Debug)]
pub(crate) enum AsyncStream {
    Unix(Async<UnixStream>),
}

impl Address {
    pub(crate) fn connect(&self, nonblocking: bool) -> Result<Stream> {
        match self {
            Address::Unix(p) => {
                let stream = unix(p)?;

                let poller = Poller::new()?;
                poller.add(&stream, Event::writable(0))?;
                poller.wait(&mut Vec::new(), None)?;

                stream.set_nonblocking(nonblocking)?;

                Ok(Stream::Unix(stream))
            }
        }
    }

    pub(crate) async fn connect_async(&self) -> Result<AsyncStream> {
        match self {
            Address::Unix(p) => Async::<UnixStream>::connect(p)
                .await
                .map(AsyncStream::Unix)
                .map_err(Error::Io),
        }
    }

    /// Get the address for session socket respecting the DBUS_SESSION_BUS_ADDRESS environment
    /// variable. If we don't recognize the value (or it's not set) we fall back to
    /// /run/user/UID/bus
    pub(crate) fn session() -> Result<Self> {
        match env::var("DBUS_SESSION_BUS_ADDRESS") {
            Ok(val) => Self::from_str(&val),
            _ => {
                let uid = Uid::current();
                let path = format!("unix:path=/run/user/{}/bus", uid);

                Self::from_str(&path)
            }
        }
    }

    /// Get the address for system bus respecting the DBUS_SYSTEM_BUS_ADDRESS environment
    /// variable. If we don't recognize the value (or it's not set) we fall back to
    /// /var/run/dbus/system_bus_socket
    pub(crate) fn system() -> Result<Self> {
        match env::var("DBUS_SYSTEM_BUS_ADDRESS") {
            Ok(val) => Self::from_str(&val),
            _ => Self::from_str("unix:path=/var/run/dbus/system_bus_socket"),
        }
    }
}

impl FromStr for Address {
    type Err = Error;

    /// Parse a D-BUS address and return its path if we recognize it
    fn from_str(address: &str) -> Result<Self> {
        // Options are given separated by commas
        let first = address.split(',').next().unwrap();
        let parts = first.split(':').collect::<Vec<&str>>();
        if parts.len() != 2 {
            return Err(Error::Address("address has no colon".into()));
        }
        if parts[0] != "unix" {
            return Err(Error::Address(format!(
                "unsupported transport '{}'",
                parts[0]
            )));
        }

        let pathparts = parts[1].split('=').collect::<Vec<&str>>();
        if pathparts.len() != 2 {
            return Err(Error::Address("address is missing '='".into()));
        }
        let path = match pathparts[0] {
            "path" => OsString::from(pathparts[1]),
            "abstract" => {
                let mut s = OsString::from("\0");
                s.push(pathparts[1]);

                s
            }
            _ => {
                return Err(Error::Address(
                    "unix address is missing path or abstract".to_owned(),
                ))
            }
        };
        Ok(Address::Unix(path))
    }
}

#[cfg(test)]
mod tests {
    use super::Address;
    use crate::Error;
    use std::str::FromStr;

    #[test]
    fn parse_dbus_addresses() {
        match Address::from_str("foo").unwrap_err() {
            Error::Address(e) => assert_eq!(e, "address has no colon"),
            _ => panic!(),
        }
        match Address::from_str("tcp:localhost").unwrap_err() {
            Error::Address(e) => assert_eq!(e, "unsupported transport 'tcp'"),
            _ => panic!(),
        }
        assert_eq!(
            Address::Unix("/tmp/dbus-foo".into()),
            Address::from_str("unix:path=/tmp/dbus-foo").unwrap()
        );
        assert_eq!(
            Address::Unix("/tmp/dbus-foo".into()),
            Address::from_str("unix:path=/tmp/dbus-foo,guid=123").unwrap()
        );
    }
}