gio/auto/

dtls_connection.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
#![allow(deprecated)]

#[cfg(feature = "v2_70")]
#[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
use crate::TlsProtocolVersion;
use crate::{
    AsyncResult, Cancellable, DatagramBased, TlsCertificate, TlsCertificateFlags, TlsDatabase,
    TlsInteraction, TlsRehandshakeMode, ffi,
};
use glib::{
    object::ObjectType as _,
    prelude::*,
    signal::{SignalHandlerId, connect_raw},
    translate::*,
};
use std::{boxed::Box as Box_, pin::Pin};

glib::wrapper! {
    ///  it is up to the caller to do that if they wish. If they
    /// do not, and [`SocketExt::close()`][crate::prelude::SocketExt::close()] is called on the base socket, the
    /// `GDtlsConnection` will not raise a `G_IO_ERROR_NOT_CONNECTED` error on
    /// further I/O.
    ///
    /// ## Properties
    ///
    ///
    /// #### `advertised-protocols`
    ///  The list of application-layer protocols that the connection
    /// advertises that it is willing to speak. See
    /// g_dtls_connection_set_advertised_protocols().
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `base-socket`
    ///  The #GDatagramBased that the connection wraps. Note that this may be any
    /// implementation of #GDatagramBased, not just a #GSocket.
    ///
    /// Readable | Writable | Construct Only
    ///
    ///
    /// #### `certificate`
    ///  The connection's certificate; see
    /// g_dtls_connection_set_certificate().
    ///
    /// Readable | Writable
    ///
    ///
    /// #### `ciphersuite-name`
    ///  The name of the DTLS ciphersuite in use. See g_dtls_connection_get_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 g_tls_backend_get_default_database().
    ///
    /// When using a non-default database, #GDtlsConnection must fall back to using
    /// the #GTlsDatabase to perform certificate verification using
    /// g_tls_database_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 #GTlsDatabase that just wraps the
    /// default #GTlsDatabase, you might expect that you have not changed anything,
    /// but this is not true because you may have altered the behavior of
    /// #GDtlsConnection by causing it to use g_tls_database_verify_chain(). See the
    /// documentation of g_tls_database_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 | Writable
    ///
    ///
    /// #### `interaction`
    ///  A #GTlsInteraction 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 | Writable
    ///
    ///
    /// #### `negotiated-protocol`
    ///  The application-layer protocol negotiated during the TLS
    /// handshake. See g_dtls_connection_get_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 #GDtlsConnection::accept-certificate.
    ///
    /// (You can watch for a #GObject::notify signal on this property to
    /// detect when a handshake has occurred.)
    ///
    /// Readable
    ///
    ///
    /// #### `peer-certificate-errors`
    ///  The errors noticed while verifying
    /// #GDtlsConnection:peer-certificate. Normally this should be 0, but
    /// it may not be if #GDtlsClientConnection:validation-flags is not
    /// [`TlsCertificateFlags::VALIDATE_ALL`][crate::TlsCertificateFlags::VALIDATE_ALL], or if
    /// #GDtlsConnection::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 DTLS protocol version in use. See g_dtls_connection_get_protocol_version().
    ///
    /// Readable
    ///
    ///
    /// #### `rehandshake-mode`
    ///  The rehandshaking mode. See
    /// g_dtls_connection_set_rehandshake_mode().
    ///
    /// Readable | Writable | Construct
    ///
    ///
    /// #### `require-close-notify`
    ///  Whether or not proper TLS close notification is required.
    /// See g_dtls_connection_set_require_close_notify().
    ///
    /// Readable | Writable | Construct
    ///
    /// ## Signals
    ///
    ///
    /// #### `accept-certificate`
    ///  Emitted during the TLS handshake after the peer certificate has
    /// been received. You can examine @peer_cert's certification path by
    /// calling g_tls_certificate_get_issuer() on it.
    ///
    /// For a client-side connection, @peer_cert is the server's
    /// certificate, and the signal will only be emitted if the
    /// certificate was not acceptable according to @conn's
    /// #GDtlsClientConnection:validation_flags. If you would like the
    /// certificate to be accepted despite @errors, return [`true`] from the
    /// signal handler. Otherwise, if no handler accepts the certificate,
    /// the handshake will fail with [`TlsError::BadCertificate`][crate::TlsError::BadCertificate].
    ///
    /// GLib guarantees that if certificate verification fails, this signal
    /// will be emitted with at least one error will be set in @errors, 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 ignore
    /// [`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.
    ///
    /// For a server-side connection, @peer_cert is the certificate
    /// presented by the client, if this was requested via the server's
    /// #GDtlsServerConnection:authentication_mode. On the server side,
    /// the signal is always emitted when the client presents a
    /// certificate, and the certificate will only be accepted if a
    /// handler returns [`true`].
    ///
    /// Note that if this signal is emitted as part of asynchronous I/O
    /// in the main thread, then you should not attempt to interact with
    /// the user before returning from the signal handler. If you want to
    /// let the user decide whether or not to accept the certificate, you
    /// would have to return [`false`] from the signal handler on the first
    /// attempt, and then after the connection attempt returns a
    /// [`TlsError::BadCertificate`][crate::TlsError::BadCertificate], you can interact with the user, and
    /// if the user decides to accept the certificate, remember that fact,
    /// create a new connection, and return [`true`] from the signal handler
    /// the next time.
    ///
    /// If you are doing I/O in another thread, you do not
    /// need to worry about this, and can simply block in the signal
    /// handler until the UI thread returns an answer.
    ///
    ///
    ///
    /// # Implements
    ///
    /// [`DtlsConnectionExt`][trait@crate::prelude::DtlsConnectionExt], [`DatagramBasedExt`][trait@crate::prelude::DatagramBasedExt], [`DatagramBasedExtManual`][trait@crate::prelude::DatagramBasedExtManual]
    #[doc(alias = "GDtlsConnection")]
    pub struct DtlsConnection(Interface<ffi::GDtlsConnection, ffi::GDtlsConnectionInterface>) @requires DatagramBased;

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

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

/// Trait containing all [`struct@DtlsConnection`] methods.
///
/// # Implementors
///
/// [`DtlsClientConnection`][struct@crate::DtlsClientConnection], [`DtlsConnection`][struct@crate::DtlsConnection], [`DtlsServerConnection`][struct@crate::DtlsServerConnection]
pub trait DtlsConnectionExt: IsA<DtlsConnection> + 'static {
    /// Close the DTLS connection. This is equivalent to calling
    /// g_dtls_connection_shutdown() to shut down both sides of the connection.
    ///
    /// Closing a #GDtlsConnection waits for all buffered but untransmitted data to
    /// be sent before it completes. It then sends a `close_notify` DTLS alert to the
    /// peer and may wait for a `close_notify` to be received from the peer. It does
    /// not close the underlying #GDtlsConnection:base-socket; that must be closed
    /// separately.
    ///
    /// Once @self is closed, all other operations will return [`IOErrorEnum::Closed`][crate::IOErrorEnum::Closed].
    /// Closing a #GDtlsConnection multiple times will not return an error.
    ///
    /// #GDtlsConnections will be automatically closed when the last reference is
    /// dropped, but you might want to call this function to make sure resources are
    /// released as early as possible.
    ///
    /// If @cancellable is cancelled, the #GDtlsConnection may be left
    /// partially-closed and any pending untransmitted data may be lost. Call
    /// g_dtls_connection_close() again to complete closing the #GDtlsConnection.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] otherwise
    #[doc(alias = "g_dtls_connection_close")]
    fn close(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_dtls_connection_close(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously close the DTLS connection. See g_dtls_connection_close() for
    /// more information.
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to call when the close operation is complete
    #[doc(alias = "g_dtls_connection_close_async")]
    fn close_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn close_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_dtls_connection_close_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = close_async_trampoline::<P>;
        unsafe {
            ffi::g_dtls_connection_close_async(
                self.as_ref().to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn close_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.close_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Used by #GDtlsConnection implementations to emit the
    /// #GDtlsConnection::accept-certificate signal.
    /// ## `peer_cert`
    /// the peer's #GTlsCertificate
    /// ## `errors`
    /// the problems with @peer_cert
    ///
    /// # Returns
    ///
    /// [`true`] if one of the signal handlers has returned
    ///     [`true`] to accept @peer_cert
    #[doc(alias = "g_dtls_connection_emit_accept_certificate")]
    fn emit_accept_certificate(
        &self,
        peer_cert: &impl IsA<TlsCertificate>,
        errors: TlsCertificateFlags,
    ) -> bool {
        unsafe {
            from_glib(ffi::g_dtls_connection_emit_accept_certificate(
                self.as_ref().to_glib_none().0,
                peer_cert.as_ref().to_glib_none().0,
                errors.into_glib(),
            ))
        }
    }

    /// Gets @self's certificate, as set by
    /// g_dtls_connection_set_certificate().
    ///
    /// # Returns
    ///
    /// @self's certificate, or [`None`]
    #[doc(alias = "g_dtls_connection_get_certificate")]
    #[doc(alias = "get_certificate")]
    fn certificate(&self) -> Option<TlsCertificate> {
        unsafe {
            from_glib_none(ffi::g_dtls_connection_get_certificate(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the name of the current DTLS ciphersuite, or [`None`] if the
    /// connection has not handshaked or has been closed. Beware that the TLS
    /// backend may use any of multiple different naming conventions, because
    /// OpenSSL and GnuTLS have their own ciphersuite naming conventions that
    /// are different from each other and different from the standard, IANA-
    /// registered ciphersuite names. The ciphersuite name is intended to be
    /// displayed to the user for informative purposes only, and parsing it
    /// is not recommended.
    ///
    /// # Returns
    ///
    /// The name of the current DTLS ciphersuite, or [`None`]
    #[cfg(feature = "v2_70")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
    #[doc(alias = "g_dtls_connection_get_ciphersuite_name")]
    #[doc(alias = "get_ciphersuite_name")]
    #[doc(alias = "ciphersuite-name")]
    fn ciphersuite_name(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_full(ffi::g_dtls_connection_get_ciphersuite_name(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the certificate database that @self uses to verify
    /// peer certificates. See g_dtls_connection_set_database().
    ///
    /// # Returns
    ///
    /// the certificate database that @self uses or [`None`]
    #[doc(alias = "g_dtls_connection_get_database")]
    #[doc(alias = "get_database")]
    fn database(&self) -> Option<TlsDatabase> {
        unsafe {
            from_glib_none(ffi::g_dtls_connection_get_database(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Get the object that will be used to interact with the user. It will be used
    /// for things like prompting the user for passwords. If [`None`] is returned, then
    /// no user interaction will occur for this connection.
    ///
    /// # Returns
    ///
    /// The interaction object.
    #[doc(alias = "g_dtls_connection_get_interaction")]
    #[doc(alias = "get_interaction")]
    fn interaction(&self) -> Option<TlsInteraction> {
        unsafe {
            from_glib_none(ffi::g_dtls_connection_get_interaction(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the name of the application-layer protocol negotiated during
    /// the handshake.
    ///
    /// If the peer did not use the ALPN extension, or did not advertise a
    /// protocol that matched one of @self's protocols, or the TLS backend
    /// does not support ALPN, then this will be [`None`]. See
    /// g_dtls_connection_set_advertised_protocols().
    ///
    /// # Returns
    ///
    /// the negotiated protocol, or [`None`]
    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "g_dtls_connection_get_negotiated_protocol")]
    #[doc(alias = "get_negotiated_protocol")]
    #[doc(alias = "negotiated-protocol")]
    fn negotiated_protocol(&self) -> Option<glib::GString> {
        unsafe {
            from_glib_none(ffi::g_dtls_connection_get_negotiated_protocol(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets @self's peer's certificate after the handshake has completed
    /// or failed. (It is not set during the emission of
    /// #GDtlsConnection::accept-certificate.)
    ///
    /// # Returns
    ///
    /// @self's peer's certificate, or [`None`]
    #[doc(alias = "g_dtls_connection_get_peer_certificate")]
    #[doc(alias = "get_peer_certificate")]
    #[doc(alias = "peer-certificate")]
    fn peer_certificate(&self) -> Option<TlsCertificate> {
        unsafe {
            from_glib_none(ffi::g_dtls_connection_get_peer_certificate(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets the errors associated with validating @self's peer's
    /// certificate, after the handshake has completed or failed. (It is
    /// not set during the emission of #GDtlsConnection::accept-certificate.)
    ///
    /// # Returns
    ///
    /// @self's peer's certificate errors
    #[doc(alias = "g_dtls_connection_get_peer_certificate_errors")]
    #[doc(alias = "get_peer_certificate_errors")]
    #[doc(alias = "peer-certificate-errors")]
    fn peer_certificate_errors(&self) -> TlsCertificateFlags {
        unsafe {
            from_glib(ffi::g_dtls_connection_get_peer_certificate_errors(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Returns the current DTLS protocol version, which may be
    /// [`TlsProtocolVersion::Unknown`][crate::TlsProtocolVersion::Unknown] if the connection has not handshaked, or
    /// has been closed, or if the TLS backend has implemented a protocol version
    /// that is not a recognized #GTlsProtocolVersion.
    ///
    /// # Returns
    ///
    /// The current DTLS protocol version
    #[cfg(feature = "v2_70")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
    #[doc(alias = "g_dtls_connection_get_protocol_version")]
    #[doc(alias = "get_protocol_version")]
    #[doc(alias = "protocol-version")]
    fn protocol_version(&self) -> TlsProtocolVersion {
        unsafe {
            from_glib(ffi::g_dtls_connection_get_protocol_version(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Gets @self rehandshaking mode. See
    /// g_dtls_connection_set_rehandshake_mode() for details.
    ///
    /// # Deprecated since 2.64
    ///
    /// Changing the rehandshake mode is no longer
    ///   required for compatibility. Also, rehandshaking has been removed
    ///   from the TLS protocol in TLS 1.3.
    ///
    /// # Returns
    ///
    /// [`TlsRehandshakeMode::Safely`][crate::TlsRehandshakeMode::Safely]
    #[cfg_attr(feature = "v2_64", deprecated = "Since 2.64")]
    #[allow(deprecated)]
    #[doc(alias = "g_dtls_connection_get_rehandshake_mode")]
    #[doc(alias = "get_rehandshake_mode")]
    #[doc(alias = "rehandshake-mode")]
    fn rehandshake_mode(&self) -> TlsRehandshakeMode {
        unsafe {
            from_glib(ffi::g_dtls_connection_get_rehandshake_mode(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Tests whether or not @self expects a proper TLS close notification
    /// when the connection is closed. See
    /// g_dtls_connection_set_require_close_notify() for details.
    ///
    /// # Returns
    ///
    /// [`true`] if @self requires a proper TLS close notification.
    #[doc(alias = "g_dtls_connection_get_require_close_notify")]
    #[doc(alias = "get_require_close_notify")]
    #[doc(alias = "require-close-notify")]
    fn requires_close_notify(&self) -> bool {
        unsafe {
            from_glib(ffi::g_dtls_connection_get_require_close_notify(
                self.as_ref().to_glib_none().0,
            ))
        }
    }

    /// Attempts a TLS handshake on @self.
    ///
    /// On the client side, it is never necessary to call this method;
    /// although the connection needs to perform a handshake after
    /// connecting, #GDtlsConnection will handle this for you automatically
    /// when you try to send or receive data on the connection. You can call
    /// g_dtls_connection_handshake() manually if you want to know whether
    /// the initial handshake succeeded or failed (as opposed to just
    /// immediately trying to use @self to read or write, in which case,
    /// if it fails, it may not be possible to tell if it failed before
    /// or after completing the handshake), but beware that servers may reject
    /// client authentication after the handshake has completed, so a
    /// successful handshake does not indicate the connection will be usable.
    ///
    /// Likewise, on the server side, although a handshake is necessary at
    /// the beginning of the communication, you do not need to call this
    /// function explicitly unless you want clearer error reporting.
    ///
    /// Previously, calling g_dtls_connection_handshake() after the initial
    /// handshake would trigger a rehandshake; however, this usage was
    /// deprecated in GLib 2.60 because rehandshaking was removed from the
    /// TLS protocol in TLS 1.3. Since GLib 2.64, calling this function after
    /// the initial handshake will no longer do anything.
    ///
    /// #GDtlsConnection::accept_certificate may be emitted during the
    /// handshake.
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// success or failure
    #[doc(alias = "g_dtls_connection_handshake")]
    fn handshake(&self, cancellable: Option<&impl IsA<Cancellable>>) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_dtls_connection_handshake(
                self.as_ref().to_glib_none().0,
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously performs a TLS handshake on @self. See
    /// g_dtls_connection_handshake() for more information.
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to call when the handshake is complete
    #[doc(alias = "g_dtls_connection_handshake_async")]
    fn handshake_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn handshake_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_dtls_connection_handshake_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = handshake_async_trampoline::<P>;
        unsafe {
            ffi::g_dtls_connection_handshake_async(
                self.as_ref().to_glib_none().0,
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn handshake_future(
        &self,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.handshake_async(io_priority, Some(cancellable), move |res| {
                    send.resolve(res);
                });
            },
        ))
    }

    /// Sets the list of application-layer protocols to advertise that the
    /// caller is willing to speak on this connection. The
    /// Application-Layer Protocol Negotiation (ALPN) extension will be
    /// used to negotiate a compatible protocol with the peer; use
    /// g_dtls_connection_get_negotiated_protocol() to find the negotiated
    /// protocol after the handshake.  Specifying [`None`] for the the value
    /// of @protocols will disable ALPN negotiation.
    ///
    /// See [IANA TLS ALPN Protocol IDs](https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids)
    /// for a list of registered protocol IDs.
    /// ## `protocols`
    /// a [`None`]-terminated
    ///   array of ALPN protocol names (eg, "http/1.1", "h2"), or [`None`]
    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "g_dtls_connection_set_advertised_protocols")]
    #[doc(alias = "advertised-protocols")]
    fn set_advertised_protocols(&self, protocols: &[&str]) {
        unsafe {
            ffi::g_dtls_connection_set_advertised_protocols(
                self.as_ref().to_glib_none().0,
                protocols.to_glib_none().0,
            );
        }
    }

    /// This sets the certificate that @self will present to its peer
    /// during the TLS handshake. For a #GDtlsServerConnection, it is
    /// mandatory to set this, and that will normally be done at construct
    /// time.
    ///
    /// For a #GDtlsClientConnection, this is optional. If a handshake fails
    /// with [`TlsError::CertificateRequired`][crate::TlsError::CertificateRequired], that means that the server
    /// requires a certificate, and if you try connecting again, you should
    /// call this method first. You can call
    /// g_dtls_client_connection_get_accepted_cas() on the failed connection
    /// to get a list of Certificate Authorities that the server will
    /// accept certificates from.
    ///
    /// (It is also possible that a server will allow the connection with
    /// or without a certificate; in that case, if you don't provide a
    /// certificate, you can tell that the server requested one by the fact
    /// that g_dtls_client_connection_get_accepted_cas() will return
    /// non-[`None`].)
    /// ## `certificate`
    /// the certificate to use for @self
    #[doc(alias = "g_dtls_connection_set_certificate")]
    #[doc(alias = "certificate")]
    fn set_certificate(&self, certificate: &impl IsA<TlsCertificate>) {
        unsafe {
            ffi::g_dtls_connection_set_certificate(
                self.as_ref().to_glib_none().0,
                certificate.as_ref().to_glib_none().0,
            );
        }
    }

    /// Sets the certificate database that is used to verify peer certificates.
    /// This is set to the default database by default. See
    /// g_tls_backend_get_default_database(). If set to [`None`], then
    /// peer certificate validation will always set the
    /// [`TlsCertificateFlags::UNKNOWN_CA`][crate::TlsCertificateFlags::UNKNOWN_CA] error (meaning
    /// #GDtlsConnection::accept-certificate will always be emitted on
    /// client-side connections, unless that bit is not set in
    /// #GDtlsClientConnection:validation-flags).
    ///
    /// There are nonintuitive security implications when using a non-default
    /// database. See #GDtlsConnection:database for details.
    /// ## `database`
    /// a #GTlsDatabase
    #[doc(alias = "g_dtls_connection_set_database")]
    #[doc(alias = "database")]
    fn set_database(&self, database: Option<&impl IsA<TlsDatabase>>) {
        unsafe {
            ffi::g_dtls_connection_set_database(
                self.as_ref().to_glib_none().0,
                database.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Set the object that will be used to interact with the user. It will be used
    /// for things like prompting the user for passwords.
    ///
    /// The @interaction argument will normally be a derived subclass of
    /// #GTlsInteraction. [`None`] can also be provided if no user interaction
    /// should occur for this connection.
    /// ## `interaction`
    /// an interaction object, or [`None`]
    #[doc(alias = "g_dtls_connection_set_interaction")]
    #[doc(alias = "interaction")]
    fn set_interaction(&self, interaction: Option<&impl IsA<TlsInteraction>>) {
        unsafe {
            ffi::g_dtls_connection_set_interaction(
                self.as_ref().to_glib_none().0,
                interaction.map(|p| p.as_ref()).to_glib_none().0,
            );
        }
    }

    /// Since GLib 2.64, changing the rehandshake mode is no longer supported
    /// and will have no effect. With TLS 1.3, rehandshaking has been removed from
    /// the TLS protocol, replaced by separate post-handshake authentication and
    /// rekey operations.
    ///
    /// # Deprecated since 2.60
    ///
    /// Changing the rehandshake mode is no longer
    ///   required for compatibility. Also, rehandshaking has been removed
    ///   from the TLS protocol in TLS 1.3.
    /// ## `mode`
    /// the rehandshaking mode
    #[cfg_attr(feature = "v2_60", deprecated = "Since 2.60")]
    #[allow(deprecated)]
    #[doc(alias = "g_dtls_connection_set_rehandshake_mode")]
    #[doc(alias = "rehandshake-mode")]
    fn set_rehandshake_mode(&self, mode: TlsRehandshakeMode) {
        unsafe {
            ffi::g_dtls_connection_set_rehandshake_mode(
                self.as_ref().to_glib_none().0,
                mode.into_glib(),
            );
        }
    }

    /// Sets whether or not @self expects a proper TLS close notification
    /// before the connection is closed. If this is [`true`] (the default),
    /// then @self will expect to receive a TLS close notification from its
    /// peer before the connection is closed, and will return a
    /// [`TlsError::Eof`][crate::TlsError::Eof] error if the connection is closed without proper
    /// notification (since this may indicate a network error, or
    /// man-in-the-middle attack).
    ///
    /// In some protocols, the application will know whether or not the
    /// connection was closed cleanly based on application-level data
    /// (because the application-level data includes a length field, or is
    /// somehow self-delimiting); in this case, the close notify is
    /// redundant and may be omitted. You
    /// can use g_dtls_connection_set_require_close_notify() to tell @self
    /// to allow an "unannounced" connection close, in which case the close
    /// will show up as a 0-length read, as in a non-TLS
    /// #GDatagramBased, and it is up to the application to check that
    /// the data has been fully received.
    ///
    /// Note that this only affects the behavior when the peer closes the
    /// connection; when the application calls g_dtls_connection_close_async() on
    /// @self itself, this will send a close notification regardless of the
    /// setting of this property. If you explicitly want to do an unclean
    /// close, you can close @self's #GDtlsConnection:base-socket rather
    /// than closing @self itself.
    /// ## `require_close_notify`
    /// whether or not to require close notification
    #[doc(alias = "g_dtls_connection_set_require_close_notify")]
    #[doc(alias = "require-close-notify")]
    fn set_require_close_notify(&self, require_close_notify: bool) {
        unsafe {
            ffi::g_dtls_connection_set_require_close_notify(
                self.as_ref().to_glib_none().0,
                require_close_notify.into_glib(),
            );
        }
    }

    ///  this
    /// is equivalent to calling g_dtls_connection_close().
    ///
    /// If @cancellable is cancelled, the #GDtlsConnection may be left
    /// partially-closed and any pending untransmitted data may be lost. Call
    /// g_dtls_connection_shutdown() again to complete closing the #GDtlsConnection.
    /// ## `shutdown_read`
    /// [`true`] to stop reception of incoming datagrams
    /// ## `shutdown_write`
    /// [`true`] to stop sending outgoing datagrams
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    ///
    /// # Returns
    ///
    /// [`true`] on success, [`false`] otherwise
    #[doc(alias = "g_dtls_connection_shutdown")]
    fn shutdown(
        &self,
        shutdown_read: bool,
        shutdown_write: bool,
        cancellable: Option<&impl IsA<Cancellable>>,
    ) -> Result<(), glib::Error> {
        unsafe {
            let mut error = std::ptr::null_mut();
            let is_ok = ffi::g_dtls_connection_shutdown(
                self.as_ref().to_glib_none().0,
                shutdown_read.into_glib(),
                shutdown_write.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                &mut error,
            );
            debug_assert_eq!(is_ok == glib::ffi::GFALSE, !error.is_null());
            if error.is_null() {
                Ok(())
            } else {
                Err(from_glib_full(error))
            }
        }
    }

    /// Asynchronously shut down part or all of the DTLS connection. See
    /// g_dtls_connection_shutdown() for more information.
    /// ## `shutdown_read`
    /// [`true`] to stop reception of incoming datagrams
    /// ## `shutdown_write`
    /// [`true`] to stop sending outgoing datagrams
    /// ## `io_priority`
    /// the [I/O priority](iface.AsyncResult.html#io-priority) of the request
    /// ## `cancellable`
    /// a #GCancellable, or [`None`]
    /// ## `callback`
    /// callback to call when the shutdown operation is complete
    #[doc(alias = "g_dtls_connection_shutdown_async")]
    fn shutdown_async<P: FnOnce(Result<(), glib::Error>) + 'static>(
        &self,
        shutdown_read: bool,
        shutdown_write: bool,
        io_priority: glib::Priority,
        cancellable: Option<&impl IsA<Cancellable>>,
        callback: P,
    ) {
        let main_context = glib::MainContext::ref_thread_default();
        let is_main_context_owner = main_context.is_owner();
        let has_acquired_main_context = (!is_main_context_owner)
            .then(|| main_context.acquire().ok())
            .flatten();
        assert!(
            is_main_context_owner || has_acquired_main_context.is_some(),
            "Async operations only allowed if the thread is owning the MainContext"
        );

        let user_data: Box_<glib::thread_guard::ThreadGuard<P>> =
            Box_::new(glib::thread_guard::ThreadGuard::new(callback));
        unsafe extern "C" fn shutdown_async_trampoline<
            P: FnOnce(Result<(), glib::Error>) + 'static,
        >(
            _source_object: *mut glib::gobject_ffi::GObject,
            res: *mut crate::ffi::GAsyncResult,
            user_data: glib::ffi::gpointer,
        ) {
            unsafe {
                let mut error = std::ptr::null_mut();
                ffi::g_dtls_connection_shutdown_finish(_source_object as *mut _, res, &mut error);
                let result = if error.is_null() {
                    Ok(())
                } else {
                    Err(from_glib_full(error))
                };
                let callback: Box_<glib::thread_guard::ThreadGuard<P>> =
                    Box_::from_raw(user_data as *mut _);
                let callback: P = callback.into_inner();
                callback(result);
            }
        }
        let callback = shutdown_async_trampoline::<P>;
        unsafe {
            ffi::g_dtls_connection_shutdown_async(
                self.as_ref().to_glib_none().0,
                shutdown_read.into_glib(),
                shutdown_write.into_glib(),
                io_priority.into_glib(),
                cancellable.map(|p| p.as_ref()).to_glib_none().0,
                Some(callback),
                Box_::into_raw(user_data) as *mut _,
            );
        }
    }

    fn shutdown_future(
        &self,
        shutdown_read: bool,
        shutdown_write: bool,
        io_priority: glib::Priority,
    ) -> Pin<Box_<dyn std::future::Future<Output = Result<(), glib::Error>> + 'static>> {
        Box_::pin(crate::GioFuture::new(
            self,
            move |obj, cancellable, send| {
                obj.shutdown_async(
                    shutdown_read,
                    shutdown_write,
                    io_priority,
                    Some(cancellable),
                    move |res| {
                        send.resolve(res);
                    },
                );
            },
        ))
    }

    /// The list of application-layer protocols that the connection
    /// advertises that it is willing to speak. See
    /// g_dtls_connection_set_advertised_protocols().
    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "advertised-protocols")]
    fn advertised_protocols(&self) -> Vec<glib::GString> {
        ObjectExt::property(self.as_ref(), "advertised-protocols")
    }

    /// The #GDatagramBased that the connection wraps. Note that this may be any
    /// implementation of #GDatagramBased, not just a #GSocket.
    #[doc(alias = "base-socket")]
    fn base_socket(&self) -> Option<DatagramBased> {
        ObjectExt::property(self.as_ref(), "base-socket")
    }

    /// Emitted during the TLS handshake after the peer certificate has
    /// been received. You can examine @peer_cert's certification path by
    /// calling g_tls_certificate_get_issuer() on it.
    ///
    /// For a client-side connection, @peer_cert is the server's
    /// certificate, and the signal will only be emitted if the
    /// certificate was not acceptable according to @conn's
    /// #GDtlsClientConnection:validation_flags. If you would like the
    /// certificate to be accepted despite @errors, return [`true`] from the
    /// signal handler. Otherwise, if no handler accepts the certificate,
    /// the handshake will fail with [`TlsError::BadCertificate`][crate::TlsError::BadCertificate].
    ///
    /// GLib guarantees that if certificate verification fails, this signal
    /// will be emitted with at least one error will be set in @errors, 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 ignore
    /// [`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.
    ///
    /// For a server-side connection, @peer_cert is the certificate
    /// presented by the client, if this was requested via the server's
    /// #GDtlsServerConnection:authentication_mode. On the server side,
    /// the signal is always emitted when the client presents a
    /// certificate, and the certificate will only be accepted if a
    /// handler returns [`true`].
    ///
    /// Note that if this signal is emitted as part of asynchronous I/O
    /// in the main thread, then you should not attempt to interact with
    /// the user before returning from the signal handler. If you want to
    /// let the user decide whether or not to accept the certificate, you
    /// would have to return [`false`] from the signal handler on the first
    /// attempt, and then after the connection attempt returns a
    /// [`TlsError::BadCertificate`][crate::TlsError::BadCertificate], you can interact with the user, and
    /// if the user decides to accept the certificate, remember that fact,
    /// create a new connection, and return [`true`] from the signal handler
    /// the next time.
    ///
    /// If you are doing I/O in another thread, you do not
    /// need to worry about this, and can simply block in the signal
    /// handler until the UI thread returns an answer.
    /// ## `peer_cert`
    /// the peer's #GTlsCertificate
    /// ## `errors`
    /// the problems with @peer_cert.
    ///
    /// # Returns
    ///
    /// [`true`] to accept @peer_cert (which will also
    /// immediately end the signal emission). [`false`] to allow the signal
    /// emission to continue, which will cause the handshake to fail if
    /// no one else overrides it.
    #[doc(alias = "accept-certificate")]
    fn connect_accept_certificate<
        F: Fn(&Self, &TlsCertificate, TlsCertificateFlags) -> bool + 'static,
    >(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn accept_certificate_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P, &TlsCertificate, TlsCertificateFlags) -> bool + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            peer_cert: *mut ffi::GTlsCertificate,
            errors: ffi::GTlsCertificateFlags,
            f: glib::ffi::gpointer,
        ) -> glib::ffi::gboolean {
            unsafe {
                let f: &F = &*(f as *const F);
                f(
                    DtlsConnection::from_glib_borrow(this).unsafe_cast_ref(),
                    &from_glib_borrow(peer_cert),
                    from_glib(errors),
                )
                .into_glib()
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"accept-certificate".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    accept_certificate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "advertised-protocols")]
    fn connect_advertised_protocols_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_advertised_protocols_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::advertised-protocols".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_advertised_protocols_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "certificate")]
    fn connect_certificate_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_certificate_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::certificate".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_certificate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_70")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
    #[doc(alias = "ciphersuite-name")]
    fn connect_ciphersuite_name_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_ciphersuite_name_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::ciphersuite-name".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_ciphersuite_name_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "database")]
    fn connect_database_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_database_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::database".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_database_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "interaction")]
    fn connect_interaction_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_interaction_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::interaction".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_interaction_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_60")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_60")))]
    #[doc(alias = "negotiated-protocol")]
    fn connect_negotiated_protocol_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_negotiated_protocol_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::negotiated-protocol".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_negotiated_protocol_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "peer-certificate")]
    fn connect_peer_certificate_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_peer_certificate_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::peer-certificate".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_peer_certificate_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "peer-certificate-errors")]
    fn connect_peer_certificate_errors_notify<F: Fn(&Self) + 'static>(
        &self,
        f: F,
    ) -> SignalHandlerId {
        unsafe extern "C" fn notify_peer_certificate_errors_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::peer-certificate-errors".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_peer_certificate_errors_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg(feature = "v2_70")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v2_70")))]
    #[doc(alias = "protocol-version")]
    fn connect_protocol_version_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_protocol_version_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::protocol-version".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_protocol_version_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[cfg_attr(feature = "v2_60", deprecated = "Since 2.60")]
    #[doc(alias = "rehandshake-mode")]
    fn connect_rehandshake_mode_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_rehandshake_mode_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::rehandshake-mode".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_rehandshake_mode_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }

    #[doc(alias = "require-close-notify")]
    fn connect_require_close_notify_notify<F: Fn(&Self) + 'static>(&self, f: F) -> SignalHandlerId {
        unsafe extern "C" fn notify_require_close_notify_trampoline<
            P: IsA<DtlsConnection>,
            F: Fn(&P) + 'static,
        >(
            this: *mut ffi::GDtlsConnection,
            _param_spec: glib::ffi::gpointer,
            f: glib::ffi::gpointer,
        ) {
            unsafe {
                let f: &F = &*(f as *const F);
                f(DtlsConnection::from_glib_borrow(this).unsafe_cast_ref())
            }
        }
        unsafe {
            let f: Box_<F> = Box_::new(f);
            connect_raw(
                self.as_ptr() as *mut _,
                c"notify::require-close-notify".as_ptr(),
                Some(std::mem::transmute::<*const (), unsafe extern "C" fn()>(
                    notify_require_close_notify_trampoline::<Self, F> as *const (),
                )),
                Box_::into_raw(f),
            )
        }
    }
}

impl<O: IsA<DtlsConnection>> DtlsConnectionExt for O {}