// 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::Credentials;
use crate::IOStream;
use glib::object::IsA;
use glib::object::ObjectType as ObjectType_;
use glib::signal::connect_raw;
use glib::signal::SignalHandlerId;
use glib::translate::*;
use std::boxed::Box as Box_;
use std::fmt;
use std::mem::transmute;

glib::wrapper! {
    /// The [`DBusAuthObserver`][crate::DBusAuthObserver] type provides a mechanism for participating
    /// in how a [`DBusServer`][crate::DBusServer] (or a [`DBusConnection`][crate::DBusConnection]) authenticates remote
    /// peers. Simply instantiate a [`DBusAuthObserver`][crate::DBusAuthObserver] 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 [`DBusServer`][crate::DBusServer] or server-side [`DBusConnection`][crate::DBusConnection] 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 # {`auth`-observer}
    ///
    /// By default, a [`DBusServer`][crate::DBusServer] or server-side [`DBusConnection`][crate::DBusConnection] 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
    /// [`DBusServerFlags::AUTHENTICATION_REQUIRE_SAME_USER`][crate::DBusServerFlags::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;
    /// }
    /// ```
    ///
    /// # 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 [`DBusAuthObserver`][crate::DBusAuthObserver] object.
    ///
    /// # Returns
    ///
    /// A [`DBusAuthObserver`][crate::DBusAuthObserver]. 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 `signal::DBusAuthObserver::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 `signal::DBusAuthObserver::authorize-authenticated-peer` signal on `self`.
    /// ## `stream`
    /// A [`IOStream`][crate::IOStream] for the [`DBusConnection`][crate::DBusConnection].
    /// ## `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 libc::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 _,
                b"allow-mechanism\0".as_ptr() as *const _,
                Some(transmute::<_, 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 [`IOStream`][crate::IOStream] for the [`DBusConnection`][crate::DBusConnection].
    /// ## `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 _,
                b"authorize-authenticated-peer\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    authorize_authenticated_peer_trampoline::<F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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

impl fmt::Display for DBusAuthObserver {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        f.write_str("DBusAuthObserver")
    }
}