🐛 Expose the socket address clients can use

src/bin/busd.rs

@@ -3,21 +3,23 @@ extern crate busd;
 #[cfg(unix)]
 use std::{fs::File, io::Write, os::fd::FromRawFd};
 
-use busd::bus;
-
 use anyhow::Result;
 use clap::Parser;
 #[cfg(unix)]
 use tokio::{select, signal::unix::SignalKind};
 use tracing::error;
 #[cfg(unix)]
 use tracing::{info, warn};
+use zbus::Address;
+
+use busd::{bus, config::BusType};
 
 /// A simple D-Bus broker.
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]
 struct Args {
     /// The address to listen on.
+    /// Takes precedence over any `<listen>` element in the configuration file.
     #[clap(short = 'a', long, value_parser)]
     address: Option<String>,
 
@@ -36,6 +38,17 @@ struct Args {
     #[cfg(unix)]
     #[clap(long)]
     ready_fd: Option<i32>,
+
+    /// Equivalent to `--address unix:tmpdir=$XDG_RUNTIME_DIR`
+    /// and --config /usr/share/dbus-1/session.conf`.
+    /// This is the default if `--system` is absent.
+    #[clap(long)]
+    session: bool,
+
+    /// Equivalent to `--address unix:path=/run/dbus/system_bus_socket`
+    /// and `--config /usr/share/dbus-1/system.conf`.
+    #[clap(long)]
+    system: bool,
 }
 
 #[tokio::main]
@@ -44,7 +57,21 @@ async fn main() -> Result<()> {
 
     let args = Args::parse();
 
-    let mut bus = bus::Bus::for_address(args.address.as_deref()).await?;
+    // TODO: when we have `Config` from #159, prefer `config.r#type` before `BusType::default()`
+    let bus_type = if args.system {
+        BusType::System
+    } else {
+        BusType::default()
+    };
+
+    // TODO: when we have `Config` from #159, prefer `config.listen` before `try_from(bus_type)`
+    let address = if let Some(address) = args.address {
+        Address::try_from(address.as_str())?
+    } else {
+        Address::try_from(bus_type)?
+    };
+
+    let mut bus = bus::Bus::for_address(&format!("{address}")).await?;
 
     #[cfg(unix)]
     if let Some(fd) = args.ready_fd {

src/bus/mod.rs

@@ -1,7 +1,6 @@
-use anyhow::{bail, Ok, Result};
-#[cfg(unix)]
-use std::{env, path::Path};
 use std::{str::FromStr, sync::Arc};
+
+use anyhow::{bail, Ok, Result};
 #[cfg(unix)]
 use tokio::fs::remove_file;
 use tokio::spawn;
@@ -45,11 +44,8 @@ enum Listener {
 }
 
 impl Bus {
-    pub async fn for_address(address: Option<&str>) -> Result<Self> {
-        let mut address = match address {
-            Some(address) => Address::from_str(address)?,
-            None => Address::from_str(&default_address())?,
-        };
+    pub async fn for_address(address: &str) -> Result<Self> {
+        let mut address = Address::from_str(address)?;
         let guid: OwnedGuid = match address.guid() {
             Some(guid) => guid.to_owned().into(),
             None => {
@@ -61,7 +57,18 @@ impl Bus {
         };
         let (listener, auth_mechanism) = match address.transport() {
             #[cfg(unix)]
-            Transport::Unix(unix) => (Self::unix_stream(unix).await?, AuthMechanism::External),
+            Transport::Unix(unix) => {
+                // resolve address specification into address that clients can use
+                let addr = Self::unix_addr(unix)?;
+                address = Address::try_from(
+                    format!("unix:path={}", addr.as_pathname().unwrap().display()).as_str(),
+                )?;
+
+                (
+                    Self::unix_stream(addr.clone()).await?,
+                    AuthMechanism::External,
+                )
+            }
             Transport::Tcp(tcp) => {
                 #[cfg(not(windows))]
                 let auth_mechanism = AuthMechanism::Anonymous;
@@ -135,14 +142,10 @@ impl Bus {
     }
 
     #[cfg(unix)]
-    async fn unix_stream(unix: &Unix) -> Result<Listener> {
-        // TODO: Use tokio::net::UnixListener directly once it supports abstract sockets:
-        //
-        // https://github.com/tokio-rs/tokio/issues/4610
-
+    fn unix_addr(unix: &Unix) -> Result<std::os::unix::net::SocketAddr> {
         use std::os::unix::net::SocketAddr;
 
-        let addr = match unix.path() {
+        Ok(match unix.path() {
             #[cfg(target_os = "linux")]
             UnixSocket::Abstract(name) => {
                 use std::os::linux::net::SocketAddrExt;
@@ -175,7 +178,15 @@ impl Bus {
                 addr
             }
             _ => bail!("Unsupported address."),
-        };
+        })
+    }
+
+    #[cfg(unix)]
+    async fn unix_stream(addr: std::os::unix::net::SocketAddr) -> Result<Listener> {
+        // TODO: Use tokio::net::UnixListener directly once it supports abstract sockets:
+        //
+        // https://github.com/tokio-rs/tokio/issues/4610
+
         let std_listener =
             tokio::task::spawn_blocking(move || std::os::unix::net::UnixListener::bind_addr(&addr))
                 .await??;
@@ -246,23 +257,3 @@ impl Bus {
         self.inner.next_id
     }
 }
-
-#[cfg(unix)]
-fn default_address() -> String {
-    let runtime_dir = env::var("XDG_RUNTIME_DIR")
-        .as_ref()
-        .map(|s| Path::new(s).to_path_buf())
-        .ok()
-        .unwrap_or_else(|| {
-            Path::new("/run")
-                .join("user")
-                .join(format!("{}", nix::unistd::Uid::current()))
-        });
-
-    format!("unix:dir={}", runtime_dir.display())
-}
-
-#[cfg(not(unix))]
-fn default_address() -> String {
-    "tcp:host=127.0.0.1,port=4242".to_string()
-}

src/config/bus_type.rs

@@ -0,0 +1,43 @@
+#[cfg(unix)]
+use std::{env, path::PathBuf};
+
+use anyhow::{Error, Result};
+use zbus::Address;
+
+#[derive(Clone, Copy, Debug, Default, PartialEq)]
+pub enum BusType {
+    #[default]
+    Session,
+    System,
+}
+
+impl TryFrom<BusType> for Address {
+    type Error = Error;
+    #[cfg(unix)]
+    fn try_from(value: BusType) -> Result<Self> {
+        if value == BusType::System {
+            return Address::try_from("unix:path=/run/dbus/system_bus_socket").map_err(Error::msg);
+        }
+
+        // BusType::Session
+        Address::try_from(format!("unix:tmpdir={}", default_session_dir().display()).as_str())
+            .map_err(Error::msg)
+    }
+
+    #[cfg(not(unix))]
+    fn try_from(_value: BusType) -> Result<Self> {
+        Address::try_from("tcp:host=127.0.0.1,port=4242").map_err(Error::msg)
+    }
+}
+
+#[cfg(unix)]
+fn default_session_dir() -> PathBuf {
+    env::var("XDG_RUNTIME_DIR")
+        .map(|s| PathBuf::from(s).to_path_buf())
+        .ok()
+        .unwrap_or_else(|| {
+            PathBuf::from("/run")
+                .join("user")
+                .join(format!("{}", nix::unistd::Uid::current()))
+        })
+}

src/config/mod.rs

@@ -0,0 +1,3 @@
+pub mod bus_type;
+
+pub use bus_type::BusType;

src/lib.rs

@@ -1,4 +1,5 @@
 pub mod bus;
+pub mod config;
 pub mod fdo;
 pub mod match_rules;
 pub mod name_registry;

tests/fdo.rs

@@ -40,7 +40,7 @@ async fn name_ownership_changes() {
 }
 
 async fn name_ownership_changes_(address: &str) {
-    let mut bus = Bus::for_address(Some(address)).await.unwrap();
+    let mut bus = Bus::for_address(address).await.unwrap();
     let (tx, rx) = tokio::sync::oneshot::channel();
 
     let handle = tokio::spawn(async move {

tests/greet.rs

@@ -45,7 +45,7 @@ async fn greet() {
 }
 
 async fn greet_(socket_addr: &str) {
-    let mut bus = Bus::for_address(Some(socket_addr)).await.unwrap();
+    let mut bus = Bus::for_address(socket_addr).await.unwrap();
     let (tx, mut rx) = channel(1);
 
     let handle = tokio::spawn(async move {

tests/monitor.rs

@@ -20,7 +20,7 @@ async fn become_monitor() {
     busd::tracing_subscriber::init();
 
     let address = "tcp:host=127.0.0.1,port=4242".to_string();
-    let mut bus = Bus::for_address(Some(&address)).await.unwrap();
+    let mut bus = Bus::for_address(&address).await.unwrap();
     let (tx, rx) = tokio::sync::oneshot::channel();
 
     let handle = tokio::spawn(async move {

tests/multiple_conns.rs

@@ -33,7 +33,7 @@ async fn multi_conenct() {
 }
 
 async fn multi_conenct_(socket_addr: &str) {
-    let mut bus = Bus::for_address(Some(socket_addr)).await.unwrap();
+    let mut bus = Bus::for_address(socket_addr).await.unwrap();
     let (tx, rx) = channel();
 
     let handle = tokio::spawn(async move {