// 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::{IOStream, TlsAuthenticationMode, TlsCertificate, TlsConnection};
use glib::{
    prelude::*,
    signal::{connect_raw, SignalHandlerId},
    translate::*,
};
use std::{boxed::Box as Box_, fmt, mem::transmute, ptr};

glib::wrapper! {
    /// [`TlsServerConnection`][crate::TlsServerConnection] is the server-side subclass of [`TlsConnection`][crate::TlsConnection],
    /// representing a server-side TLS connection.
    ///
    /// ## Properties
    ///
    ///
    /// #### `authentication-mode`
    ///  The [`TlsAuthenticationMode`][crate::TlsAuthenticationMode] for the server. This can be changed
    /// before calling [`TlsConnectionExt::handshake()`][crate::prelude::TlsConnectionExt::handshake()] if you want to
    /// rehandshake with a different mode from the initial handshake.
    ///
    /// Readable | Writeable
    /// <details><summary><h4>TlsConnection</h4></summary>
    ///
    ///
    /// #### `advertised-protocols`
    ///  The list of application-layer protocols that the connection
    /// advertises that it is willing to speak. See
    /// [`TlsConnectionExtManual::set_advertised_protocols()`][crate::prelude::TlsConnectionExtManual::set_advertised_protocols()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `base-io-stream`
    ///  The [`IOStream`][crate::IOStream] that the connection wraps. The connection holds a reference
    /// to this stream, and may run operations on the stream from other threads
    /// throughout its lifetime. Consequently, after the [`IOStream`][crate::IOStream] has been
    /// constructed, application code may only run its own operations on this
    /// stream when no [`IOStream`][crate::IOStream] operations are running.
    ///
    /// Readable | Writeable | Construct Only
    ///
    ///
    /// #### `certificate`
    ///  The connection's certificate; see
    /// [`TlsConnectionExt::set_certificate()`][crate::prelude::TlsConnectionExt::set_certificate()].
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `ciphersuite-name`
    ///  The name of the TLS ciphersuite in use. See [`TlsConnectionExt::ciphersuite_name()`][crate::prelude::TlsConnectionExt::ciphersuite_name()].
    ///
    /// Readable
    ///
    ///
    /// #### `database`
    ///  The certificate database to use when verifying this TLS connection.
    /// If no certificate database is set, then the default database will be
    /// used. See [`TlsBackendExt::default_database()`][crate::prelude::TlsBackendExt::default_database()].
    ///
    /// When using a non-default database, [`TlsConnection`][crate::TlsConnection] must fall back to using
    /// the [`TlsDatabase`][crate::TlsDatabase] to perform certificate verification using
    /// [`TlsDatabaseExt::verify_chain()`][crate::prelude::TlsDatabaseExt::verify_chain()], which means certificate verification will
    /// not be able to make use of TLS session context. This may be less secure.
    /// For example, if you create your own [`TlsDatabase`][crate::TlsDatabase] that just wraps the
    /// default [`TlsDatabase`][crate::TlsDatabase], you might expect that you have not changed anything,
    /// but this is not true because you may have altered the behavior of
    /// [`TlsConnection`][crate::TlsConnection] by causing it to use [`TlsDatabaseExt::verify_chain()`][crate::prelude::TlsDatabaseExt::verify_chain()]. See the
    /// documentation of [`TlsDatabaseExt::verify_chain()`][crate::prelude::TlsDatabaseExt::verify_chain()] for more details on specific
    /// security checks that may not be performed. Accordingly, setting a
    /// non-default database is discouraged except for specialty applications with
    /// unusual security requirements.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `interaction`
    ///  A [`TlsInteraction`][crate::TlsInteraction] object to be used when the connection or certificate
    /// database need to interact with the user. This will be used to prompt the
    /// user for passwords where necessary.
    ///
    /// Readable | Writeable
    ///
    ///
    /// #### `negotiated-protocol`
    ///  The application-layer protocol negotiated during the TLS
    /// handshake. See [`TlsConnectionExt::negotiated_protocol()`][crate::prelude::TlsConnectionExt::negotiated_protocol()].
    ///
    /// Readable
    ///
    ///
    /// #### `peer-certificate`
    ///  The connection's peer's certificate, after the TLS handshake has
    /// completed or failed. Note in particular that this is not yet set
    /// during the emission of [`accept-certificate`][struct@crate::TlsConnection#accept-certificate].
    ///
    /// (You can watch for a [`notify`][struct@crate::glib::Object#notify] signal on this property to
    /// detect when a handshake has occurred.)
    ///
    /// Readable
    ///
    ///
    /// #### `peer-certificate-errors`
    ///  The errors noticed while verifying
    /// [`peer-certificate`][struct@crate::TlsConnection#peer-certificate]. Normally this should be 0, but
    /// it may not be if [`validation-flags`][struct@crate::TlsClientConnection#validation-flags] is not
    /// [`TlsCertificateFlags::VALIDATE_ALL`][crate::TlsCertificateFlags::VALIDATE_ALL], or if
    /// [`accept-certificate`][struct@crate::TlsConnection#accept-certificate] overrode the default
    /// behavior.
    ///
    /// GLib guarantees that if certificate verification fails, at least
    /// one error will be set, but it does not guarantee that all possible
    /// errors will be set. Accordingly, you may not safely decide to
    /// ignore any particular type of error. For example, it would be
    /// incorrect to mask [`TlsCertificateFlags::EXPIRED`][crate::TlsCertificateFlags::EXPIRED] if you want to allow
    /// expired certificates, because this could potentially be the only
    /// error flag set even if other problems exist with the certificate.
    ///
    /// Readable
    ///
    ///
    /// #### `protocol-version`
    ///  The TLS protocol version in use. See [`TlsConnectionExt::protocol_version()`][crate::prelude::TlsConnectionExt::protocol_version()].
    ///
    /// Readable
    ///
    ///
    /// #### `rehandshake-mode`
    ///  The rehandshaking mode. See
    /// [`TlsConnectionExt::set_rehandshake_mode()`][crate::prelude::TlsConnectionExt::set_rehandshake_mode()].
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `require-close-notify`
    ///  Whether or not proper TLS close notification is required.
    /// See [`TlsConnectionExt::set_require_close_notify()`][crate::prelude::TlsConnectionExt::set_require_close_notify()].
    ///
    /// Readable | Writeable | Construct
    ///
    ///
    /// #### `use-system-certdb`
    ///  Whether or not the system certificate database will be used to
    /// verify peer certificates. See
    /// `g_tls_connection_set_use_system_certdb()`.
    ///
    /// Readable | Writeable | Construct
    /// </details>
    /// <details><summary><h4>IOStream</h4></summary>
    ///
    ///
    /// #### `closed`
    ///  Readable
    ///
    ///
    /// #### `input-stream`
    ///  Readable
    ///
    ///
    /// #### `output-stream`
    ///  Readable
    /// </details>
    ///
    /// # Implements
    ///
    /// [`TlsServerConnectionExt`][trait@crate::prelude::TlsServerConnectionExt], [`TlsConnectionExt`][trait@crate::prelude::TlsConnectionExt], [`IOStreamExt`][trait@crate::prelude::IOStreamExt], [`trait@glib::ObjectExt`], [`TlsConnectionExtManual`][trait@crate::prelude::TlsConnectionExtManual], [`IOStreamExtManual`][trait@crate::prelude::IOStreamExtManual]
    #[doc(alias = "GTlsServerConnection")]
    pub struct TlsServerConnection(Interface<ffi::GTlsServerConnection, ffi::GTlsServerConnectionInterface>) @requires TlsConnection, IOStream;

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

impl TlsServerConnection {
    pub const NONE: Option<&'static TlsServerConnection> = None;

    /// Creates a new [`TlsServerConnection`][crate::TlsServerConnection] wrapping `base_io_stream` (which
    /// must have pollable input and output streams).
    ///
    /// See the documentation for [`base-io-stream`][struct@crate::TlsConnection#base-io-stream] for restrictions
    /// on when application code can run operations on the `base_io_stream` after
    /// this function has returned.
    /// ## `base_io_stream`
    /// the [`IOStream`][crate::IOStream] to wrap
    /// ## `certificate`
    /// the default server certificate, or [`None`]
    ///
    /// # Returns
    ///
    /// the new
    /// [`TlsServerConnection`][crate::TlsServerConnection], or [`None`] on error
    #[doc(alias = "g_tls_server_connection_new")]
    pub fn new(
        base_io_stream: &impl IsA<IOStream>,
        certificate: Option<&impl IsA<TlsCertificate>>,
    ) -> Result<TlsServerConnection, glib::Error> {
        unsafe {
            let mut error = ptr::null_mut();
            let ret = ffi::g_tls_server_connection_new(
                base_io_stream.as_ref().to_glib_none().0,
                certificate.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            if error.is_null() {
                Ok(from_glib_full(ret))
            } else {
                Err(from_glib_full(error))
            }
        }
    }
}

/// Trait containing all [`struct@TlsServerConnection`] methods.
///
/// # Implementors
///
/// [`TlsServerConnection`][struct@crate::TlsServerConnection]
pub trait TlsServerConnectionExt: 'static {
    /// The [`TlsAuthenticationMode`][crate::TlsAuthenticationMode] for the server. This can be changed
    /// before calling [`TlsConnectionExt::handshake()`][crate::prelude::TlsConnectionExt::handshake()] if you want to
    /// rehandshake with a different mode from the initial handshake.
    #[doc(alias = "authentication-mode")]
    fn authentication_mode(&self) -> TlsAuthenticationMode;

    /// The [`TlsAuthenticationMode`][crate::TlsAuthenticationMode] for the server. This can be changed
    /// before calling [`TlsConnectionExt::handshake()`][crate::prelude::TlsConnectionExt::handshake()] if you want to
    /// rehandshake with a different mode from the initial handshake.
    #[doc(alias = "authentication-mode")]
    fn set_authentication_mode(&self, authentication_mode: TlsAuthenticationMode);

    #[doc(alias = "authentication-mode")]
    fn connect_authentication_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId;
}

impl<O: IsA<TlsServerConnection>> TlsServerConnectionExt for O {
    fn authentication_mode(&self) -> TlsAuthenticationMode {
        glib::ObjectExt::property(self.as_ref(), "authentication-mode")
    }

    fn set_authentication_mode(&self, authentication_mode: TlsAuthenticationMode) {
        glib::ObjectExt::set_property(self.as_ref(), "authentication-mode", authentication_mode)
    }

    fn connect_authentication_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_authentication_mode_trampoline<
            P: IsA<TlsServerConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GTlsServerConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            let f: &F = &*(f as *const F);
            f(TlsServerConnection::from_glib_borrow(this).unsafe_cast_ref())
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                b"notify::authentication-mode\0".as_ptr() as *const _,
                Some(transmute::<_, unsafe extern "C" fn()>(
                    notify_authentication_mode_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

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