passcod_networkmanager/
connection.rs

1use crate::configs::{Dhcp4Config, Dhcp6Config, Ip4Config, Ip6Config};
2use crate::dbus_api::DBusAccessor;
3use crate::devices::Device;
4use crate::gen::OrgFreedesktopNetworkManagerConnectionActive;
5use crate::types::{ActivationStateFlags, ActiveConnectionState};
6use crate::Error;
7use num_traits::FromPrimitive;
8
9#[derive(Clone, Debug)]
10pub struct Connection {
11    dbus_accessor: DBusAccessor,
12}
13
14impl Connection {
15    pub(crate) fn new(dbus_accessor: DBusAccessor) -> Self {
16        Connection { dbus_accessor }
17    }
18    pub fn connection(&self) -> Result<String, Error> {
19        Ok(proxy!(self).connection()?.to_string())
20    }
21    pub fn specific_object(&self) -> Result<String, Error> {
22        Ok(proxy!(self).specific_object()?.to_string())
23    }
24    pub fn id(&self) -> Result<String, Error> {
25        Ok(proxy!(self).id()?)
26    }
27    pub fn uuid(&self) -> Result<String, Error> {
28        Ok(proxy!(self).uuid()?)
29    }
30    pub fn type_(&self) -> Result<String, Error> {
31        Ok(proxy!(self).type_()?)
32    }
33    pub fn devices(&self) -> Result<Vec<Device>, Error> {
34        let device_paths = proxy!(self).devices()?;
35        let mut res = Vec::new();
36        for dev_path in device_paths {
37            res.push(Device::new(self.dbus_accessor.with_path(dev_path))?);
38        }
39        Ok(res)
40    }
41    pub fn state(&self) -> Result<ActiveConnectionState, Error> {
42        let state = proxy!(self).state()?;
43        match FromPrimitive::from_u32(state) {
44            Some(x) => Ok(x),
45            None => Err(Error::UnsupportedType),
46        }
47    }
48    pub fn state_flags(&self) -> Result<ActivationStateFlags, Error> {
49        let state = proxy!(self).state_flags()?;
50        match FromPrimitive::from_u32(state) {
51            Some(x) => Ok(x),
52            None => Err(Error::UnsupportedType),
53        }
54    }
55    pub fn default(&self) -> Result<bool, Error> {
56        Ok(proxy!(self).default()?)
57    }
58    pub fn ip4_config(&self) -> Result<Ip4Config, Error> {
59        let path = proxy!(self).ip4_config()?;
60        Ok(Ip4Config::new(self.dbus_accessor.with_path(path)))
61    }
62    pub fn dhcp4_config(&self) -> Result<Dhcp4Config, Error> {
63        let path = proxy!(self).dhcp4_config()?;
64        Ok(Dhcp4Config::new(self.dbus_accessor.with_path(path)))
65    }
66    pub fn default6(&self) -> Result<bool, Error> {
67        Ok(proxy!(self).default6()?)
68    }
69    pub fn ip6_config(&self) -> Result<Ip6Config, Error> {
70        let path = proxy!(self).ip6_config()?;
71        Ok(Ip6Config::new(self.dbus_accessor.with_path(path)))
72    }
73    pub fn dhcp6_config(&self) -> Result<Dhcp6Config, Error> {
74        let path = proxy!(self).dhcp6_config()?;
75        Ok(Dhcp6Config::new(self.dbus_accessor.with_path(path)))
76    }
77    pub fn vpn(&self) -> Result<bool, Error> {
78        Ok(proxy!(self).vpn()?)
79    }
80    pub fn master(&self) -> Result<Device, Error> {
81        let dev_path = proxy!(self).master()?;
82        Device::new(self.dbus_accessor.with_path(dev_path))
83    }
84}