Struct ConfigurationNodeProxy

pub struct ConfigurationNodeProxy<'c>(/* private fields */);

Configuration Object

Implementations

impl<'c> ConfigurationNodeProxy<'c>

pub async fn new(conn: &Connection) -> Result<ConfigurationNodeProxy<'c>>

Creates a new proxy with the default service and path.

pub fn builder(conn: &Connection) -> ProxyBuilder<'c, Self>

Returns a customizable builder for this proxy.

pub fn into_inner(self) -> Proxy<'c>

Consumes self, returning the underlying zbus::Proxy.

pub fn inner(&self) -> &Proxy<'c>

The reference to the underlying zbus::Proxy.

pub async fn access_grant(&self, uid: u32) -> Result<()>

AccessGrant method

By default, only the user ID (UID) who imported the configuration have access to it. This method used to grant other users access to the configuration.

Arguments

• uid - The UID to the user account which is granted access.

pub async fn access_revoke(&self, uid: u32) -> Result<()>

AccessRevoke method

This revokes access to a configuration object for a specific user. Please note that the owner (the user which imported the configuration) cannot have its access revoked.

Arguments

• uid - The UID to the user account which gets the access revoked.

pub async fn fetch(&self) -> Result<String>

Fetch method

This method will return a string of the stored configuration profile as it is stored. This should be contain the same information which was imported. It will not necessarily be an identical copy of what was imported, as it has been processed during the import.

Returns

The configuration file as a plain string blob.

pub async fn fetch_json(&self) -> Result<String>

FetchJSON method

This is a variant of Fetch, which returns the configuration profile formatted as a JSON string blob. The intention of this is for user front-ends to have a simple API to retrieve the complete configuration profile in a format which can easily be parsed and presented in a user interface.

Returns

The configuration file as a JSON formatted string blob.

pub async fn remove(&self) -> Result<()>

Remove method

Removes a VPN profile from the configuration manager. If the configuration is persistent, it will be removed from the disk as well. This method takes no arguments and does not return anything on success. If an error occurs, a D-Bus error is returned.

pub async fn seal(&self) -> Result<()>

Seal method

This method makes the configuration read-only. That means it can no longer be manipulated, nor removed.

pub async fn set_option(&self, option: &str, value: &str) -> Result<()>

SetOption method

This method allows manipulation of a stored configuration. This is targeted at user front-ends to be able to easily manipulate imported configuration files.

** WARNING: ** This method is currently not implemented!

Arguments

• option - String containing the name of the option to be modified.
• value - String containing the new value of the option.

pub async fn set_override(&self, name: &str, value: &Value<'_>) -> Result<()>

SetOverride method

Modifies an override parameter in the configuration profile.

Arguments

• name - Property name to modify.
• value - The new value the property should have. The data type ov must match the data type of the property in the D-Bus object.

pub async fn unset_override(&self, name: &str) -> Result<()>

UnsetOverride method

Unset an override setting.

Arguments

• name - Override property name to remove.

pub async fn acl(&self) -> Result<Vec<u32>>

An array of UID values granted access.

pub fn cached_acl( &self, ) -> Result<Option<<Result<Vec<u32>> as ResultAdapter>::Ok>, <Result<Vec<u32>> as ResultAdapter>::Err>

Get the cached value of the acl property, or None if the property is not cached.

pub async fn receive_acl_changed( &self, ) -> PropertyStream<'c, <Result<Vec<u32>> as ResultAdapter>::Ok>

Create a stream for the acl property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn dco(&self) -> Result<bool>

If set to true, the VPN tunnel will make use of the kernel accelerated Data Channel Offload (DCO) feature (requires kernel support).

pub fn cached_dco( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the dco property, or None if the property is not cached.

pub async fn receive_dco_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the dco property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_dco(&self, value: bool) -> Result<()>

pub async fn import_timestamp(&self) -> Result<u64>

Unix Epoch timestamp of the import time.

pub fn cached_import_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the import_timestamp property, or None if the property is not cached.

pub async fn receive_import_timestamp_changed( &self, ) -> PropertyStream<'c, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the import_timestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn last_used_timestamp(&self) -> Result<u64>

Unix Epoch timestamp of the last time it Fetch was called.

It will track/count Fetch usage only if the calling user is openvpn.

pub fn cached_last_used_timestamp( &self, ) -> Result<Option<<Result<u64> as ResultAdapter>::Ok>, <Result<u64> as ResultAdapter>::Err>

Get the cached value of the last_used_timestamp property, or None if the property is not cached.

pub async fn receive_last_used_timestamp_changed( &self, ) -> PropertyStream<'c, <Result<u64> as ResultAdapter>::Ok>

Create a stream for the last_used_timestamp property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn locked_down(&self) -> Result<bool>

If set to true, only the owner and openvpn user can retrieve the configuration file. Other users granted access can only use this profile to start a new tunnel.

pub fn cached_locked_down( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the locked_down property, or None if the property is not cached.

pub async fn receive_locked_down_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the locked_down property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_locked_down(&self, value: bool) -> Result<()>

pub async fn name(&self) -> Result<String>

Contains the user friendly name of the configuration profile

pub fn cached_name( &self, ) -> Result<Option<<Result<String> as ResultAdapter>::Ok>, <Result<String> as ResultAdapter>::Err>

Get the cached value of the name property, or None if the property is not cached.

pub async fn receive_name_changed( &self, ) -> PropertyStream<'c, <Result<String> as ResultAdapter>::Ok>

Create a stream for the name property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_name(&self, value: &str) -> Result<()>

pub async fn overrides(&self) -> Result<HashMap<String, OwnedValue>>

Contains all the override settings enabled. This is stored as a key/value based dictionary, where value can be any arbitrary data type.

pub fn cached_overrides( &self, ) -> Result<Option<<Result<HashMap<String, OwnedValue>> as ResultAdapter>::Ok>, <Result<HashMap<String, OwnedValue>> as ResultAdapter>::Err>

Get the cached value of the overrides property, or None if the property is not cached.

pub async fn receive_overrides_changed( &self, ) -> PropertyStream<'c, <Result<HashMap<String, OwnedValue>> as ResultAdapter>::Ok>

Create a stream for the overrides property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn owner(&self) -> Result<u32>

The UID value of the user which did the import.

pub fn cached_owner( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

Get the cached value of the owner property, or None if the property is not cached.

pub async fn receive_owner_changed( &self, ) -> PropertyStream<'c, <Result<u32> as ResultAdapter>::Ok>

Create a stream for the owner property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn persistent(&self) -> Result<bool>

If set to true, this configuration will be saved to disk by the configuration manager. The location of the file storage is managed by the configuration manager itself and the configuration manager will load persistent profiles each time it starts.

pub fn cached_persistent( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the persistent property, or None if the property is not cached.

pub async fn receive_persistent_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the persistent property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn public_access(&self) -> Result<bool>

If set to true, access control is disabled. But only owner may change this property, modify the ACL or delete the configuration.

pub fn cached_public_access( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the public_access property, or None if the property is not cached.

pub async fn receive_public_access_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the public_access property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_public_access(&self, value: bool) -> Result<()>

pub async fn readonly(&self) -> Result<bool>

If set to true, the configuration have been sealed and can no longer be modified.

pub fn cached_readonly( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the readonly property, or None if the property is not cached.

pub async fn receive_readonly_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the readonly property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn single_use(&self) -> Result<bool>

If set to true, this configuration profile will be automatically removed after the first Fetch call. This is intended to be used by command line clients providing a similar user experience as the OpenVPN 2.x versions provides.

pub fn cached_single_use( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the single_use property, or None if the property is not cached.

pub async fn receive_single_use_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the single_use property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn transfer_owner_session(&self) -> Result<bool>

If set to true, another user granted access to this profile will transfer the VPN session ownership back to the profile owner at start up.

pub fn cached_transfer_owner_session( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the transfer_owner_session property, or None if the property is not cached.

pub async fn receive_transfer_owner_session_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the transfer_owner_session property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn set_transfer_owner_session(&self, value: bool) -> Result<()>

pub async fn used_count(&self) -> Result<u32>

Number of times Fetch has been called.

It will track/count Fetch usage only if the calling user is openvpn.

pub fn cached_used_count( &self, ) -> Result<Option<<Result<u32> as ResultAdapter>::Ok>, <Result<u32> as ResultAdapter>::Err>

Get the cached value of the used_count property, or None if the property is not cached.

pub async fn receive_used_count_changed( &self, ) -> PropertyStream<'c, <Result<u32> as ResultAdapter>::Ok>

Create a stream for the used_count property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

pub async fn valid(&self) -> Result<bool>

Contains an indication if the configuration profile is considered functional for a VPN session.

pub fn cached_valid( &self, ) -> Result<Option<<Result<bool> as ResultAdapter>::Ok>, <Result<bool> as ResultAdapter>::Err>

Get the cached value of the valid property, or None if the property is not cached.

pub async fn receive_valid_changed( &self, ) -> PropertyStream<'c, <Result<bool> as ResultAdapter>::Ok>

Create a stream for the valid property changes. This is a convenient wrapper around zbus::Proxy::receive_property_changed.

Methods from Deref<Target = Proxy<'c>>

pub fn connection(&self) -> &Connection

Get a reference to the associated connection.

pub fn destination(&self) -> &BusName<'_>

Get a reference to the destination service name.

pub fn path(&self) -> &ObjectPath<'_>

Get a reference to the object path.

Examples found in repository

examples/basic.rs (line 50)

fn main() {
    task::block_on(async {
        let connection = zbus::Connection::system().await.unwrap();
        let config_manager = openvpn3_rs::ConfigurationProxy::new(&connection)
            .await
            .unwrap();
        let config = config_manager
            .import("My VPN", CONFIG_STR, true, false)
            .await
            .unwrap();

        let sessions_manager = openvpn3_rs::SessionsProxy::new(&connection).await.unwrap();
        let session = sessions_manager.new_tunnel(&config.path()).await.unwrap();

        let mut ready = false;
        while !ready {
            // If the session is ready, the `ready()` method will return Ok(), otherwise an error will be returned with more details.
            if let Err(err) = session.ready().await {
                let err_str = err.to_string();
                if err_str.contains("Missing user credentials") {
                    // This loop queries the session for which credentials are needed. This example covers username/password authentication.

                    let ui_type_group = session.user_input_queue_get_type_group().await.unwrap();

                    for (ca_type, ca_group) in ui_type_group {
                        let ui_queue_ids = session
                            .user_input_queue_check(ca_type, ca_group)
                            .await
                            .unwrap();

                        for id in ui_queue_ids {
                            let (ca_type, ca_group, id, name, _description, _hidden_input) =
                                session
                                    .user_input_queue_fetch(ca_type, ca_group, id)
                                    .await
                                    .unwrap();

                            if name == "username" {
                                session
                                    .user_input_provide(ca_type, ca_group, id, "smith")
                                    .await
                                    .unwrap();
                            }

                            if name == "password" {
                                session
                                    .user_input_provide(ca_type, ca_group, id, "hunter2")
                                    .await
                                    .unwrap();
                            }
                        }
                    }
                } else if err_str.contains("Backend VPN process is not ready") {
                    task::sleep(std::time::Duration::from_secs(1)).await;
                }
            } else {
                ready = true;
            }
        }

        session.connect().await.unwrap();

        // wait for signal to disconnect

        session.disconnect().await.unwrap();
    });
}

pub fn interface(&self) -> &InterfaceName<'_>

Get a reference to the interface.

pub async fn introspect(&self) -> Result<String, Error>

Introspect the associated object, and return the XML description.

See the xml or quick_xml module for parsing the result.

pub fn cached_property<T>( &self, property_name: &str, ) -> Result<Option<T>, Error>

where T: TryFrom<OwnedValue>, <T as TryFrom<OwnedValue>>::Error: Into<Error>,

Get the cached value of the property property_name.

This returns None if the property is not in the cache. This could be because the cache was invalidated by an update, because caching was disabled for this property or proxy, or because the cache has not yet been populated. Use get_property to fetch the value from the peer.

pub fn cached_property_raw<'p>( &'p self, property_name: &'p str, ) -> Option<impl Deref<Target = Value<'static>> + 'p>

Get the cached value of the property property_name.

Same as cached_property, but gives you access to the raw value stored in the cache. This is useful if you want to avoid allocations and cloning.

pub async fn get_property<T>(&self, property_name: &str) -> Result<T, Error>

where T: TryFrom<OwnedValue>, <T as TryFrom<OwnedValue>>::Error: Into<Error>,

Get the property property_name.

Get the property value from the cache (if caching is enabled) or call the Get method of the org.freedesktop.DBus.Properties interface.

pub async fn set_property<'t, T>( &self, property_name: &str, value: T, ) -> Result<(), Error>

where T: 't + Into<Value<'t>>,

Set the property property_name.

Effectively, call the Set method of the org.freedesktop.DBus.Properties interface.

pub async fn call_method<'m, M, B>( &self, method_name: M, body: &B, ) -> Result<Arc<Message>, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType,

Call a method and return the reply.

Typically, you would want to use call method instead. Use this method if you need to deserialize the reply message manually (this way, you can avoid the memory allocation/copying, by deserializing the reply to an unowned type).

pub async fn call<'m, M, B, R>( &self, method_name: M, body: &B, ) -> Result<R, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType, R: DeserializeOwned + Type,

Call a method and return the reply body.

Use call_method instead if you need to deserialize the reply manually/separately.

pub async fn call_with_flags<'m, M, B, R>( &self, method_name: M, flags: BitFlags<MethodFlags>, body: &B, ) -> Result<Option<R>, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType, R: DeserializeOwned + Type,

Call a method and return the reply body, optionally supplying a set of method flags to control the way the method call message is sent and handled.

Use call instead if you do not need any special handling via additional flags. If the NoReplyExpected flag is passed , this will return None immediately after sending the message, similar to call_noreply

pub async fn call_noreply<'m, M, B>( &self, method_name: M, body: &B, ) -> Result<(), Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>, B: Serialize + DynamicType,

Call a method without expecting a reply

This sets the NoReplyExpected flag on the calling message and does not wait for a reply.

pub async fn receive_signal<'m, M>( &self, signal_name: M, ) -> Result<SignalStream<'m>, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>,

Create a stream for signal named signal_name.

pub async fn receive_signal_with_args<'m, M>( &self, signal_name: M, args: &[(u8, &str)], ) -> Result<SignalStream<'m>, Error>

where M: TryInto<MemberName<'m>>, <M as TryInto<MemberName<'m>>>::Error: Into<Error>,

Same as Proxy::receive_signal but with a filter.

The D-Bus specification allows you to filter signals by their arguments, which helps avoid a lot of unnecessary traffic and processing since the filter is run on the server side. Use this method where possible. Note that this filtering is limited to arguments of string types.

The arguments are passed as a tuples of argument index and expected value.

pub async fn receive_all_signals(&self) -> Result<SignalStream<'static>, Error>

Create a stream for all signals emitted by this service.

pub async fn receive_property_changed<'name, T>( &self, name: &'name str, ) -> PropertyStream<'a, T>

where 'name: 'a,

Get a stream to receive property changed events.

Note that zbus doesn’t queue the updates. If the listener is slower than the receiver, it will only receive the last update.

If caching is not enabled on this proxy, the resulting stream will not return any events.

pub async fn receive_owner_changed( &self, ) -> Result<OwnerChangedStream<'_>, Error>

Get a stream to receive destination owner changed events.

If the proxy destination is a unique name, the stream will be notified of the peer disconnection from the bus (with a None value).

If the proxy destination is a well-known name, the stream will be notified whenever the name owner is changed, either by a new peer being granted ownership (Some value) or when the name is released (with a None value).

Note that zbus doesn’t queue the updates. If the listener is slower than the receiver, it will only receive the last update.

Trait Implementations

impl<'c> AsMut<Proxy<'c>> for ConfigurationNodeProxy<'c>

fn as_mut(&mut self) -> &mut Proxy<'c>

Converts this type into a mutable reference of the (usually inferred) input type.

impl<'c> AsRef<Proxy<'c>> for ConfigurationNodeProxy<'c>

fn as_ref(&self) -> &Proxy<'c>

Converts this type into a shared reference of the (usually inferred) input type.

impl<'c> Clone for ConfigurationNodeProxy<'c>

fn clone(&self) -> ConfigurationNodeProxy<'c>

Returns a duplicate of the value.

const fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<'c> Debug for ConfigurationNodeProxy<'c>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<'c> Deref for ConfigurationNodeProxy<'c>

type Target = Proxy<'c>

The resulting type after dereferencing.

fn deref(&self) -> &Self::Target

Dereferences the value.

impl<'c> DerefMut for ConfigurationNodeProxy<'c>

fn deref_mut(&mut self) -> &mut Self::Target

Mutably dereferences the value.

impl<'c> From<Proxy<'c>> for ConfigurationNodeProxy<'c>

fn from(proxy: Proxy<'c>) -> Self

Converts to this type from the input type.

impl<'a> ProxyDefault for ConfigurationNodeProxy<'a>

const INTERFACE: &'static str = "net.openvpn.v3.configuration"

const DESTINATION: &'static str = "net.openvpn.v3.configuration"

const PATH: &'static str = "/net/openvpn/v3/configuration"

impl<'c> Serialize for ConfigurationNodeProxy<'c>

fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>

where S: Serializer,

Serialize this value into the given Serde serializer.

impl<'c> Type for ConfigurationNodeProxy<'c>

fn signature() -> Signature<'static>

Get the signature for the implementing type.