/* GIO - GLib Input, Output and Streaming Library * * Copyright © 2010 Red Hat, Inc * Copyright © 2015 Collabora, Ltd. * * This library is free software; you can redistribute it and/or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation; either * version 2.1 of the License, or (at your option) any later version. * * This library is distributed in the hope that it will be useful, * but WITHOUT ANY WARRANTY; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU * Lesser General Public License for more details. * * You should have received a copy of the GNU Lesser General * Public License along with this library; if not, see . */ #include "config.h" #include "glib.h" #include "gdtlsconnection.h" #include "gcancellable.h" #include "gioenumtypes.h" #include "gsocket.h" #include "gtlsbackend.h" #include "gtlscertificate.h" #include "gtlsconnection.h" #include "gdtlsclientconnection.h" #include "gtlsdatabase.h" #include "gtlsinteraction.h" #include "glibintl.h" #include "gmarshal-internal.h" /** * SECTION:gdtlsconnection * @short_description: DTLS connection type * @include: gio/gio.h * * #GDtlsConnection is the base DTLS connection class type, which wraps * a #GDatagramBased and provides DTLS encryption on top of it. Its * subclasses, #GDtlsClientConnection and #GDtlsServerConnection, * implement client-side and server-side DTLS, respectively. * * For TLS support, see #GTlsConnection. * * As DTLS is datagram based, #GDtlsConnection implements #GDatagramBased, * presenting a datagram-socket-like API for the encrypted connection. This * operates over a base datagram connection, which is also a #GDatagramBased * (#GDtlsConnection:base-socket). * * To close a DTLS connection, use g_dtls_connection_close(). * * Neither #GDtlsServerConnection or #GDtlsClientConnection set the peer address * on their base #GDatagramBased if it is a #GSocket — it is up to the caller to * do that if they wish. If they do not, and g_socket_close() is called on the * base socket, the #GDtlsConnection will not raise a %G_IO_ERROR_NOT_CONNECTED * error on further I/O. * * Since: 2.48 */ /** * GDtlsConnection: * * Abstract base class for the backend-specific #GDtlsClientConnection * and #GDtlsServerConnection types. * * Since: 2.48 */ G_DEFINE_INTERFACE (GDtlsConnection, g_dtls_connection, G_TYPE_DATAGRAM_BASED) enum { ACCEPT_CERTIFICATE, LAST_SIGNAL }; static guint signals[LAST_SIGNAL] = { 0 }; enum { PROP_BASE_SOCKET = 1, PROP_REQUIRE_CLOSE_NOTIFY, PROP_REHANDSHAKE_MODE, PROP_DATABASE, PROP_INTERACTION, PROP_CERTIFICATE, PROP_PEER_CERTIFICATE, PROP_PEER_CERTIFICATE_ERRORS, PROP_PROTOCOL_VERSION, PROP_CIPHERSUITE_NAME, }; static void g_dtls_connection_default_init (GDtlsConnectionInterface *iface) { /** * GDtlsConnection:base-socket: * * The #GDatagramBased that the connection wraps. Note that this may be any * implementation of #GDatagramBased, not just a #GSocket. * * Since: 2.48 */ g_object_interface_install_property (iface, g_param_spec_object ("base-socket", P_("Base Socket"), P_("The GDatagramBased that the connection wraps"), G_TYPE_DATAGRAM_BASED, G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:database: (nullable) * * 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(). * * Since: 2.48 */ g_object_interface_install_property (iface, g_param_spec_object ("database", P_("Database"), P_("Certificate database to use for looking up or verifying certificates"), G_TYPE_TLS_DATABASE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:interaction: (nullable) * * 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. * * Since: 2.48 */ g_object_interface_install_property (iface, g_param_spec_object ("interaction", P_("Interaction"), P_("Optional object for user interaction"), G_TYPE_TLS_INTERACTION, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:require-close-notify: * * Whether or not proper TLS close notification is required. * See g_dtls_connection_set_require_close_notify(). * * Since: 2.48 */ g_object_interface_install_property (iface, g_param_spec_boolean ("require-close-notify", P_("Require close notify"), P_("Whether to require proper TLS close notification"), TRUE, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:rehandshake-mode: * * The rehandshaking mode. See * g_dtls_connection_set_rehandshake_mode(). * * Since: 2.48 * * Deprecated: 2.60: The rehandshake mode is ignored. */ g_object_interface_install_property (iface, g_param_spec_enum ("rehandshake-mode", P_("Rehandshake mode"), P_("When to allow rehandshaking"), G_TYPE_TLS_REHANDSHAKE_MODE, G_TLS_REHANDSHAKE_NEVER, G_PARAM_READWRITE | G_PARAM_CONSTRUCT | G_PARAM_STATIC_STRINGS | G_PARAM_DEPRECATED)); /** * GDtlsConnection:certificate: * * The connection's certificate; see * g_dtls_connection_set_certificate(). * * Since: 2.48 */ g_object_interface_install_property (iface, g_param_spec_object ("certificate", P_("Certificate"), P_("The connection’s certificate"), G_TYPE_TLS_CERTIFICATE, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:peer-certificate: (nullable) * * 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.) * * Since: 2.48 */ g_object_interface_install_property (iface, g_param_spec_object ("peer-certificate", P_("Peer Certificate"), P_("The connection’s peer’s certificate"), G_TYPE_TLS_CERTIFICATE, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection: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 * %G_TLS_CERTIFICATE_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 %G_TLS_CERTIFICATE_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. * * Since: 2.48 */ g_object_interface_install_property (iface, g_param_spec_flags ("peer-certificate-errors", P_("Peer Certificate Errors"), P_("Errors found with the peer’s certificate"), G_TYPE_TLS_CERTIFICATE_FLAGS, 0, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:advertised-protocols: (nullable) * * The list of application-layer protocols that the connection * advertises that it is willing to speak. See * g_dtls_connection_set_advertised_protocols(). * * Since: 2.60 */ g_object_interface_install_property (iface, g_param_spec_boxed ("advertised-protocols", P_("Advertised Protocols"), P_("Application-layer protocols available on this connection"), G_TYPE_STRV, G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:negotiated-protocol: * * The application-layer protocol negotiated during the TLS * handshake. See g_dtls_connection_get_negotiated_protocol(). * * Since: 2.60 */ g_object_interface_install_property (iface, g_param_spec_string ("negotiated-protocol", P_("Negotiated Protocol"), P_("Application-layer protocol negotiated for this connection"), NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:protocol-version: * * The DTLS protocol version in use. See g_dtls_connection_get_protocol_version(). * * Since: 2.70 */ g_object_interface_install_property (iface, g_param_spec_enum ("protocol-version", P_("Protocol Version"), P_("DTLS protocol version negotiated for this connection"), G_TYPE_TLS_PROTOCOL_VERSION, G_TLS_PROTOCOL_VERSION_UNKNOWN, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection:ciphersuite-name: (nullable) * * The name of the DTLS ciphersuite in use. See g_dtls_connection_get_ciphersuite_name(). * * Since: 2.70 */ g_object_interface_install_property (iface, g_param_spec_string ("ciphersuite-name", P_("Ciphersuite Name"), P_("Name of ciphersuite negotiated for this connection"), NULL, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); /** * GDtlsConnection::accept-certificate: * @conn: a #GDtlsConnection * @peer_cert: the peer's #GTlsCertificate * @errors: the problems with @peer_cert. * * 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 %G_TLS_ERROR_BAD_CERTIFICATE. * * 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 * %G_TLS_CERTIFICATE_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 * %G_TLS_ERROR_BAD_CERTIFICATE, 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. * * 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. * * Since: 2.48 */ signals[ACCEPT_CERTIFICATE] = g_signal_new (I_("accept-certificate"), G_TYPE_DTLS_CONNECTION, G_SIGNAL_RUN_LAST, G_STRUCT_OFFSET (GDtlsConnectionInterface, accept_certificate), g_signal_accumulator_true_handled, NULL, _g_cclosure_marshal_BOOLEAN__OBJECT_FLAGS, G_TYPE_BOOLEAN, 2, G_TYPE_TLS_CERTIFICATE, G_TYPE_TLS_CERTIFICATE_FLAGS); g_signal_set_va_marshaller (signals[ACCEPT_CERTIFICATE], G_TYPE_FROM_INTERFACE (iface), _g_cclosure_marshal_BOOLEAN__OBJECT_FLAGSv); } /** * g_dtls_connection_set_database: * @conn: a #GDtlsConnection * @database: (nullable): a #GTlsDatabase * * 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 %NULL, then * peer certificate validation will always set the * %G_TLS_CERTIFICATE_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). * * Since: 2.48 */ void g_dtls_connection_set_database (GDtlsConnection *conn, GTlsDatabase *database) { g_return_if_fail (G_IS_DTLS_CONNECTION (conn)); g_return_if_fail (database == NULL || G_IS_TLS_DATABASE (database)); g_object_set (G_OBJECT (conn), "database", database, NULL); } /** * g_dtls_connection_get_database: * @conn: a #GDtlsConnection * * Gets the certificate database that @conn uses to verify * peer certificates. See g_dtls_connection_set_database(). * * Returns: (transfer none) (nullable): the certificate database that @conn uses or %NULL * * Since: 2.48 */ GTlsDatabase* g_dtls_connection_get_database (GDtlsConnection *conn) { GTlsDatabase *database = NULL; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), NULL); g_object_get (G_OBJECT (conn), "database", &database, NULL); if (database) g_object_unref (database); return database; } /** * g_dtls_connection_set_certificate: * @conn: a #GDtlsConnection * @certificate: the certificate to use for @conn * * This sets the certificate that @conn 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 %G_TLS_ERROR_CERTIFICATE_REQUIRED, 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-%NULL.) * * Since: 2.48 */ void g_dtls_connection_set_certificate (GDtlsConnection *conn, GTlsCertificate *certificate) { g_return_if_fail (G_IS_DTLS_CONNECTION (conn)); g_return_if_fail (G_IS_TLS_CERTIFICATE (certificate)); g_object_set (G_OBJECT (conn), "certificate", certificate, NULL); } /** * g_dtls_connection_get_certificate: * @conn: a #GDtlsConnection * * Gets @conn's certificate, as set by * g_dtls_connection_set_certificate(). * * Returns: (transfer none) (nullable): @conn's certificate, or %NULL * * Since: 2.48 */ GTlsCertificate * g_dtls_connection_get_certificate (GDtlsConnection *conn) { GTlsCertificate *certificate; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), NULL); g_object_get (G_OBJECT (conn), "certificate", &certificate, NULL); if (certificate) g_object_unref (certificate); return certificate; } /** * g_dtls_connection_set_interaction: * @conn: a connection * @interaction: (nullable): an interaction object, or %NULL * * 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. %NULL can also be provided if no user interaction * should occur for this connection. * * Since: 2.48 */ void g_dtls_connection_set_interaction (GDtlsConnection *conn, GTlsInteraction *interaction) { g_return_if_fail (G_IS_DTLS_CONNECTION (conn)); g_return_if_fail (interaction == NULL || G_IS_TLS_INTERACTION (interaction)); g_object_set (G_OBJECT (conn), "interaction", interaction, NULL); } /** * g_dtls_connection_get_interaction: * @conn: a connection * * 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 %NULL is returned, then * no user interaction will occur for this connection. * * Returns: (transfer none) (nullable): The interaction object. * * Since: 2.48 */ GTlsInteraction * g_dtls_connection_get_interaction (GDtlsConnection *conn) { GTlsInteraction *interaction = NULL; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), NULL); g_object_get (G_OBJECT (conn), "interaction", &interaction, NULL); if (interaction) g_object_unref (interaction); return interaction; } /** * g_dtls_connection_get_peer_certificate: * @conn: a #GDtlsConnection * * Gets @conn's peer's certificate after the handshake has completed * or failed. (It is not set during the emission of * #GDtlsConnection::accept-certificate.) * * Returns: (transfer none) (nullable): @conn's peer's certificate, or %NULL * * Since: 2.48 */ GTlsCertificate * g_dtls_connection_get_peer_certificate (GDtlsConnection *conn) { GTlsCertificate *peer_certificate; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), NULL); g_object_get (G_OBJECT (conn), "peer-certificate", &peer_certificate, NULL); if (peer_certificate) g_object_unref (peer_certificate); return peer_certificate; } /** * g_dtls_connection_get_peer_certificate_errors: * @conn: a #GDtlsConnection * * Gets the errors associated with validating @conn's peer's * certificate, after the handshake has completed or failed. (It is * not set during the emission of #GDtlsConnection::accept-certificate.) * * Returns: @conn's peer's certificate errors * * Since: 2.48 */ GTlsCertificateFlags g_dtls_connection_get_peer_certificate_errors (GDtlsConnection *conn) { GTlsCertificateFlags errors; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), 0); g_object_get (G_OBJECT (conn), "peer-certificate-errors", &errors, NULL); return errors; } /** * g_dtls_connection_set_require_close_notify: * @conn: a #GDtlsConnection * @require_close_notify: whether or not to require close notification * * Sets whether or not @conn expects a proper TLS close notification * before the connection is closed. If this is %TRUE (the default), * then @conn will expect to receive a TLS close notification from its * peer before the connection is closed, and will return a * %G_TLS_ERROR_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 @conn * 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 * @conn 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 @conn's #GDtlsConnection:base-socket rather * than closing @conn itself. * * Since: 2.48 */ void g_dtls_connection_set_require_close_notify (GDtlsConnection *conn, gboolean require_close_notify) { g_return_if_fail (G_IS_DTLS_CONNECTION (conn)); g_object_set (G_OBJECT (conn), "require-close-notify", require_close_notify, NULL); } /** * g_dtls_connection_get_require_close_notify: * @conn: a #GDtlsConnection * * Tests whether or not @conn expects a proper TLS close notification * when the connection is closed. See * g_dtls_connection_set_require_close_notify() for details. * * Returns: %TRUE if @conn requires a proper TLS close notification. * * Since: 2.48 */ gboolean g_dtls_connection_get_require_close_notify (GDtlsConnection *conn) { gboolean require_close_notify; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), TRUE); g_object_get (G_OBJECT (conn), "require-close-notify", &require_close_notify, NULL); return require_close_notify; } /** * g_dtls_connection_set_rehandshake_mode: * @conn: a #GDtlsConnection * @mode: the rehandshaking mode * * 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. * * Since: 2.48 * * Deprecated: 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. */ G_GNUC_BEGIN_IGNORE_DEPRECATIONS void g_dtls_connection_set_rehandshake_mode (GDtlsConnection *conn, GTlsRehandshakeMode mode) { g_return_if_fail (G_IS_DTLS_CONNECTION (conn)); g_object_set (G_OBJECT (conn), "rehandshake-mode", G_TLS_REHANDSHAKE_SAFELY, NULL); } G_GNUC_END_IGNORE_DEPRECATIONS /** * g_dtls_connection_get_rehandshake_mode: * @conn: a #GDtlsConnection * * Gets @conn rehandshaking mode. See * g_dtls_connection_set_rehandshake_mode() for details. * * Returns: %G_TLS_REHANDSHAKE_SAFELY * * Since: 2.48 * * Deprecated: 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. */ G_GNUC_BEGIN_IGNORE_DEPRECATIONS GTlsRehandshakeMode g_dtls_connection_get_rehandshake_mode (GDtlsConnection *conn) { GTlsRehandshakeMode mode; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), G_TLS_REHANDSHAKE_SAFELY); /* Continue to call g_object_get(), even though the return value is * ignored, so that behavior doesn’t change for derived classes. */ g_object_get (G_OBJECT (conn), "rehandshake-mode", &mode, NULL); return G_TLS_REHANDSHAKE_SAFELY; } G_GNUC_END_IGNORE_DEPRECATIONS /** * g_dtls_connection_handshake: * @conn: a #GDtlsConnection * @cancellable: (nullable): a #GCancellable, or %NULL * @error: a #GError, or %NULL * * Attempts a TLS handshake on @conn. * * 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 @conn 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. * * Returns: success or failure * * Since: 2.48 */ gboolean g_dtls_connection_handshake (GDtlsConnection *conn, GCancellable *cancellable, GError **error) { g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), FALSE); return G_DTLS_CONNECTION_GET_INTERFACE (conn)->handshake (conn, cancellable, error); } /** * g_dtls_connection_handshake_async: * @conn: a #GDtlsConnection * @io_priority: the [I/O priority][io-priority] of the request * @cancellable: (nullable): a #GCancellable, or %NULL * @callback: callback to call when the handshake is complete * @user_data: the data to pass to the callback function * * Asynchronously performs a TLS handshake on @conn. See * g_dtls_connection_handshake() for more information. * * Since: 2.48 */ void g_dtls_connection_handshake_async (GDtlsConnection *conn, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_return_if_fail (G_IS_DTLS_CONNECTION (conn)); G_DTLS_CONNECTION_GET_INTERFACE (conn)->handshake_async (conn, io_priority, cancellable, callback, user_data); } /** * g_dtls_connection_handshake_finish: * @conn: a #GDtlsConnection * @result: a #GAsyncResult. * @error: a #GError pointer, or %NULL * * Finish an asynchronous TLS handshake operation. See * g_dtls_connection_handshake() for more information. * * Returns: %TRUE on success, %FALSE on failure, in which * case @error will be set. * * Since: 2.48 */ gboolean g_dtls_connection_handshake_finish (GDtlsConnection *conn, GAsyncResult *result, GError **error) { g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), FALSE); return G_DTLS_CONNECTION_GET_INTERFACE (conn)->handshake_finish (conn, result, error); } /** * g_dtls_connection_shutdown: * @conn: a #GDtlsConnection * @shutdown_read: %TRUE to stop reception of incoming datagrams * @shutdown_write: %TRUE to stop sending outgoing datagrams * @cancellable: (nullable): a #GCancellable, or %NULL * @error: a #GError, or %NULL * * Shut down part or all of a DTLS connection. * * If @shutdown_read is %TRUE then the receiving side of the connection is shut * down, and further reading is disallowed. Subsequent calls to * g_datagram_based_receive_messages() will return %G_IO_ERROR_CLOSED. * * If @shutdown_write is %TRUE then the sending side of the connection is shut * down, and further writing is disallowed. Subsequent calls to * g_datagram_based_send_messages() will return %G_IO_ERROR_CLOSED. * * It is allowed for both @shutdown_read and @shutdown_write to be TRUE — 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. * * Returns: %TRUE on success, %FALSE otherwise * * Since: 2.48 */ gboolean g_dtls_connection_shutdown (GDtlsConnection *conn, gboolean shutdown_read, gboolean shutdown_write, GCancellable *cancellable, GError **error) { GDtlsConnectionInterface *iface; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), FALSE); g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); if (!shutdown_read && !shutdown_write) return TRUE; iface = G_DTLS_CONNECTION_GET_INTERFACE (conn); g_assert (iface->shutdown != NULL); return iface->shutdown (conn, shutdown_read, shutdown_write, cancellable, error); } /** * g_dtls_connection_shutdown_async: * @conn: a #GDtlsConnection * @shutdown_read: %TRUE to stop reception of incoming datagrams * @shutdown_write: %TRUE to stop sending outgoing datagrams * @io_priority: the [I/O priority][io-priority] of the request * @cancellable: (nullable): a #GCancellable, or %NULL * @callback: callback to call when the shutdown operation is complete * @user_data: the data to pass to the callback function * * Asynchronously shut down part or all of the DTLS connection. See * g_dtls_connection_shutdown() for more information. * * Since: 2.48 */ void g_dtls_connection_shutdown_async (GDtlsConnection *conn, gboolean shutdown_read, gboolean shutdown_write, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { GDtlsConnectionInterface *iface; g_return_if_fail (G_IS_DTLS_CONNECTION (conn)); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); iface = G_DTLS_CONNECTION_GET_INTERFACE (conn); g_assert (iface->shutdown_async != NULL); iface->shutdown_async (conn, TRUE, TRUE, io_priority, cancellable, callback, user_data); } /** * g_dtls_connection_shutdown_finish: * @conn: a #GDtlsConnection * @result: a #GAsyncResult * @error: a #GError pointer, or %NULL * * Finish an asynchronous TLS shutdown operation. See * g_dtls_connection_shutdown() for more information. * * Returns: %TRUE on success, %FALSE on failure, in which * case @error will be set * * Since: 2.48 */ gboolean g_dtls_connection_shutdown_finish (GDtlsConnection *conn, GAsyncResult *result, GError **error) { GDtlsConnectionInterface *iface; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); iface = G_DTLS_CONNECTION_GET_INTERFACE (conn); g_assert (iface->shutdown_finish != NULL); return iface->shutdown_finish (conn, result, error); } /** * g_dtls_connection_close: * @conn: a #GDtlsConnection * @cancellable: (nullable): a #GCancellable, or %NULL * @error: a #GError, or %NULL * * 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 @conn is closed, all other operations will return %G_IO_ERROR_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. * * Returns: %TRUE on success, %FALSE otherwise * * Since: 2.48 */ gboolean g_dtls_connection_close (GDtlsConnection *conn, GCancellable *cancellable, GError **error) { g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), FALSE); g_return_val_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); return G_DTLS_CONNECTION_GET_INTERFACE (conn)->shutdown (conn, TRUE, TRUE, cancellable, error); } /** * g_dtls_connection_close_async: * @conn: a #GDtlsConnection * @io_priority: the [I/O priority][io-priority] of the request * @cancellable: (nullable): a #GCancellable, or %NULL * @callback: callback to call when the close operation is complete * @user_data: the data to pass to the callback function * * Asynchronously close the DTLS connection. See g_dtls_connection_close() for * more information. * * Since: 2.48 */ void g_dtls_connection_close_async (GDtlsConnection *conn, int io_priority, GCancellable *cancellable, GAsyncReadyCallback callback, gpointer user_data) { g_return_if_fail (G_IS_DTLS_CONNECTION (conn)); g_return_if_fail (cancellable == NULL || G_IS_CANCELLABLE (cancellable)); G_DTLS_CONNECTION_GET_INTERFACE (conn)->shutdown_async (conn, TRUE, TRUE, io_priority, cancellable, callback, user_data); } /** * g_dtls_connection_close_finish: * @conn: a #GDtlsConnection * @result: a #GAsyncResult * @error: a #GError pointer, or %NULL * * Finish an asynchronous TLS close operation. See g_dtls_connection_close() * for more information. * * Returns: %TRUE on success, %FALSE on failure, in which * case @error will be set * * Since: 2.48 */ gboolean g_dtls_connection_close_finish (GDtlsConnection *conn, GAsyncResult *result, GError **error) { g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); return G_DTLS_CONNECTION_GET_INTERFACE (conn)->shutdown_finish (conn, result, error); } /** * g_dtls_connection_emit_accept_certificate: * @conn: a #GDtlsConnection * @peer_cert: the peer's #GTlsCertificate * @errors: the problems with @peer_cert * * Used by #GDtlsConnection implementations to emit the * #GDtlsConnection::accept-certificate signal. * * Returns: %TRUE if one of the signal handlers has returned * %TRUE to accept @peer_cert * * Since: 2.48 */ gboolean g_dtls_connection_emit_accept_certificate (GDtlsConnection *conn, GTlsCertificate *peer_cert, GTlsCertificateFlags errors) { gboolean accept = FALSE; g_signal_emit (conn, signals[ACCEPT_CERTIFICATE], 0, peer_cert, errors, &accept); return accept; } /** * g_dtls_connection_set_advertised_protocols: * @conn: a #GDtlsConnection * @protocols: (array zero-terminated=1) (nullable): a %NULL-terminated * array of ALPN protocol names (eg, "http/1.1", "h2"), or %NULL * * 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 %NULL 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. * * Since: 2.60 */ void g_dtls_connection_set_advertised_protocols (GDtlsConnection *conn, const gchar * const *protocols) { GDtlsConnectionInterface *iface; iface = G_DTLS_CONNECTION_GET_INTERFACE (conn); if (iface->set_advertised_protocols == NULL) return; iface->set_advertised_protocols (conn, protocols); } /** * g_dtls_connection_get_negotiated_protocol: * @conn: a #GDtlsConnection * * 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 @conn's protocols, or the TLS backend * does not support ALPN, then this will be %NULL. See * g_dtls_connection_set_advertised_protocols(). * * Returns: (nullable): the negotiated protocol, or %NULL * * Since: 2.60 */ const gchar * g_dtls_connection_get_negotiated_protocol (GDtlsConnection *conn) { GDtlsConnectionInterface *iface; iface = G_DTLS_CONNECTION_GET_INTERFACE (conn); if (iface->get_negotiated_protocol == NULL) return NULL; return iface->get_negotiated_protocol (conn); } /** * g_dtls_connection_get_channel_binding_data: * @conn: a #GDtlsConnection * @type: #GTlsChannelBindingType type of data to fetch * @data: (out callee-allocates)(optional)(transfer none): #GByteArray is * filled with the binding data, or %NULL * @error: a #GError pointer, or %NULL * * Query the TLS backend for TLS channel binding data of @type for @conn. * * This call retrieves TLS channel binding data as specified in RFC * [5056](https://tools.ietf.org/html/rfc5056), RFC * [5929](https://tools.ietf.org/html/rfc5929), and related RFCs. The * binding data is returned in @data. The @data is resized by the callee * using #GByteArray buffer management and will be freed when the @data * is destroyed by g_byte_array_unref(). If @data is %NULL, it will only * check whether TLS backend is able to fetch the data (e.g. whether @type * is supported by the TLS backend). It does not guarantee that the data * will be available though. That could happen if TLS connection does not * support @type or the binding data is not available yet due to additional * negotiation or input required. * * Returns: %TRUE on success, %FALSE otherwise * * Since: 2.66 */ gboolean g_dtls_connection_get_channel_binding_data (GDtlsConnection *conn, GTlsChannelBindingType type, GByteArray *data, GError **error) { GDtlsConnectionInterface *iface; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), FALSE); g_return_val_if_fail (error == NULL || *error == NULL, FALSE); iface = G_DTLS_CONNECTION_GET_INTERFACE (conn); if (iface->get_binding_data == NULL) { g_set_error_literal (error, G_TLS_CHANNEL_BINDING_ERROR, G_TLS_CHANNEL_BINDING_ERROR_NOT_IMPLEMENTED, _("TLS backend does not implement TLS binding retrieval")); return FALSE; } return iface->get_binding_data (conn, type, data, error); } /** * g_dtls_connection_get_protocol_version: * @conn: a #GDTlsConnection * * Returns the current DTLS protocol version, which may be * %G_TLS_PROTOCOL_VERSION_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 * * Since: 2.70 */ GTlsProtocolVersion g_dtls_connection_get_protocol_version (GDtlsConnection *conn) { GTlsProtocolVersion protocol_version; GEnumClass *enum_class; GEnumValue *enum_value; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), G_TLS_PROTOCOL_VERSION_UNKNOWN); g_object_get (G_OBJECT (conn), "protocol-version", &protocol_version, NULL); /* Convert unknown values to G_TLS_PROTOCOL_VERSION_UNKNOWN. */ enum_class = g_type_class_peek_static (G_TYPE_TLS_PROTOCOL_VERSION); enum_value = g_enum_get_value (enum_class, protocol_version); return enum_value ? protocol_version : G_TLS_PROTOCOL_VERSION_UNKNOWN; } /** * g_dtls_connection_get_ciphersuite_name: * @conn: a #GDTlsConnection * * Returns the name of the current DTLS ciphersuite, or %NULL 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: (nullable): The name of the current DTLS ciphersuite, or %NULL * * Since: 2.70 */ gchar * g_dtls_connection_get_ciphersuite_name (GDtlsConnection *conn) { gchar *ciphersuite_name; g_return_val_if_fail (G_IS_DTLS_CONNECTION (conn), NULL); g_object_get (G_OBJECT (conn), "ciphersuite-name", &ciphersuite_name, NULL); return g_steal_pointer (&ciphersuite_name); }