gio/auto/

dbus_auth_observer.rs

// This file was generated by gir (https://github.com/gtk-rs/gir)
// from gir-files (https://github.com/gtk-rs/gir-files)
// DO NOT EDIT

use crate::{ffi, Credentials, IOStream};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::boxed::Box as Box_;

glib::wrapper! {
    /// `GDBusAuthObserver` provides a mechanism for participating
    /// in how a [`DBusServer`][crate::DBusServer] (or a [`DBusConnection`][crate::DBusConnection])
    /// authenticates remote peers.
    ///
    /// Simply instantiate a `GDBusAuthObserver` and connect to the
    /// signals you are interested in. Note that new signals may be added
    /// in the future.
    ///
    /// ## Controlling Authentication Mechanisms
    ///
    /// By default, a `GDBusServer` or server-side `GDBusConnection` will allow
    /// any authentication mechanism to be used. If you only want to allow D-Bus
    /// connections with the `EXTERNAL` mechanism, which makes use of credentials
    /// passing and is the recommended mechanism for modern Unix platforms such
    /// as Linux and the BSD family, you would use a signal handler like this:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static gboolean
    /// on_allow_mechanism (GDBusAuthObserver *observer,
    ///                     const gchar       *mechanism,
    ///                     gpointer           user_data)
    /// {
    ///   if (g_strcmp0 (mechanism, "EXTERNAL") == 0)
    ///     {
    ///       return TRUE;
    ///     }
    ///
    ///   return FALSE;
    /// }
    /// ```
    ///
    /// ## Controlling Authorization
    ///
    /// By default, a `GDBusServer` or server-side `GDBusConnection` will accept
    /// connections from any successfully authenticated user (but not from
    /// anonymous connections using the `ANONYMOUS` mechanism). If you only
    /// want to allow D-Bus connections from processes owned by the same uid
    /// as the server, since GLib 2.68, you should use the
    /// `G_DBUS_SERVER_FLAGS_AUTHENTICATION_REQUIRE_SAME_USER` flag. It’s equivalent
    /// to the following signal handler:
    ///
    /// **⚠️ The following code is in c ⚠️**
    ///
    /// ```c
    /// static gboolean
    /// on_authorize_authenticated_peer (GDBusAuthObserver *observer,
    ///                                  GIOStream         *stream,
    ///                                  GCredentials      *credentials,
    ///                                  gpointer           user_data)
    /// {
    ///   gboolean authorized;
    ///
    ///   authorized = FALSE;
    ///   if (credentials != NULL)
    ///     {
    ///       GCredentials *own_credentials;
    ///       own_credentials = g_credentials_new ();
    ///       if (g_credentials_is_same_user (credentials, own_credentials, NULL))
    ///         authorized = TRUE;
    ///       g_object_unref (own_credentials);
    ///     }
    ///
    ///   return authorized;
    /// }
    /// ```
    ///
    /// ## Signals
    ///
    ///
    /// #### `allow-mechanism`
    ///  Emitted to check if @mechanism is allowed to be used.
    ///
    ///
    ///
    ///
    /// #### `authorize-authenticated-peer`
    ///  Emitted to check if a peer that is successfully authenticated
    /// is authorized.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`trait@glib::ObjectExt`]
    #[doc(alias = "GDBusAuthObserver")]
    pub struct DBusAuthObserver(Object<ffi::GDBusAuthObserver>);

    match fn {
        type_ => || ffi::g_dbus_auth_observer_get_type(),
    }
}

impl DBusAuthObserver {
    /// Creates a new #GDBusAuthObserver object.
    ///
    /// # Returns
    ///
    /// A #GDBusAuthObserver. Free with g_object_unref().
    #[doc(alias = "g_dbus_auth_observer_new")]
    pub fn new() -> DBusAuthObserver {
        unsafe { from_glib_full(ffi::g_dbus_auth_observer_new()) }
    }

    /// Emits the #GDBusAuthObserver::allow-mechanism signal on @self.
    /// ## `mechanism`
    /// The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`.
    ///
    /// # Returns
    ///
    /// [`true`] if @mechanism can be used to authenticate the other peer, [`false`] if not.
    #[doc(alias = "g_dbus_auth_observer_allow_mechanism")]
    pub fn allow_mechanism(&self, mechanism: &str) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_auth_observer_allow_mechanism(
                self.to_glib_none().0,
                mechanism.to_glib_none().0,
            ))
        }
    }

    /// Emits the #GDBusAuthObserver::authorize-authenticated-peer signal on @self.
    /// ## `stream`
    /// A #GIOStream for the #GDBusConnection.
    /// ## `credentials`
    /// Credentials received from the peer or [`None`].
    ///
    /// # Returns
    ///
    /// [`true`] if the peer is authorized, [`false`] if not.
    #[doc(alias = "g_dbus_auth_observer_authorize_authenticated_peer")]
    pub fn authorize_authenticated_peer(
        &self,
        stream: &impl IsA<IOStream>,
        credentials: Option<&Credentials>,
    ) -> bool {
        unsafe {
            from_glib(ffi::g_dbus_auth_observer_authorize_authenticated_peer(
                self.to_glib_none().0,
                stream.as_ref().to_glib_none().0,
                credentials.to_glib_none().0,
            ))
        }
    }

    /// Emitted to check if @mechanism is allowed to be used.
    /// ## `mechanism`
    /// The name of the mechanism, e.g. `DBUS_COOKIE_SHA1`.
    ///
    /// # Returns
    ///
    /// [`true`] if @mechanism can be used to authenticate the other peer, [`false`] if not.
    #[doc(alias = "allow-mechanism")]
    pub fn connect_allow_mechanism<F: Fn(&Self, &str) -> bool + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn allow_mechanism_trampoline<
            F: Fn(&DBusAuthObserver, &str) -> bool + 'static,
        >(
            this: *mut ffi::GDBusAuthObserver,
            mechanism: *mut std::ffi::c_char,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &glib::GString::from_glib_borrow(mechanism),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"allow-mechanism".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    allow_mechanism_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    /// Emitted to check if a peer that is successfully authenticated
    /// is authorized.
    /// ## `stream`
    /// A #GIOStream for the #GDBusConnection.
    /// ## `credentials`
    /// Credentials received from the peer or [`None`].
    ///
    /// # Returns
    ///
    /// [`true`] if the peer is authorized, [`false`] if not.
    #[doc(alias = "authorize-authenticated-peer")]
    pub fn connect_authorize_authenticated_peer<
        F: Fn(&Self, &IOStream, Option<&Credentials>) -> bool + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn authorize_authenticated_peer_trampoline<
            F: Fn(&DBusAuthObserver, &IOStream, Option<&Credentials>) -> bool + 'static,
        >(
            this: *mut ffi::GDBusAuthObserver,
            stream: *mut ffi::GIOStream,
            credentials: *mut ffi::GCredentials,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            let f: &F = &*(f as *const F);
            f(
                &from_glib_borrow(this),
                &from_glib_borrow(stream),
                Option::<Credentials>::from_glib_borrow(credentials)
                    .as_ref()
                    .as_ref(),
            )
            .into_glib()
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"authorize-authenticated-peer".as_ptr() as *const _,
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    authorize_authenticated_peer_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl Default for DBusAuthObserver {
    fn default() -> Self {
        Self::new()
    }
}