Package ch.bailu.gtk.gio

Class TlsClientConnection

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.gobject.Object
ch.bailu.gtk.type.Interface
ch.bailu.gtk.gio.TlsClientConnection
All Implemented Interfaces:
PointerInterface
public class TlsClientConnection extends Interface
#GTlsClientConnection is the client-side subclass of
#GTlsConnection, representing a client-side TLS connection.

https://docs.gtk.org/gio/iface.TlsClientConnection.html

  • Constructor Details

  • Method Details

    • getClassHandler

      public static ClassHandler getClassHandler()

    • copySessionState

      public void copySessionState(@Nonnull TlsClientConnection source)
      Possibly copies session state from one connection to another, for use
      in TLS session resumption. This is not normally needed, but may be
      used when the same session needs to be used between different
      endpoints, as is required by some protocols, such as FTP over TLS.
      @source should have already completed a handshake and, since TLS 1.3,
      it should have been used to read data at least once. @conn should not
      have completed a handshake.

      It is not possible to know whether a call to this function will
      actually do anything. Because session resumption is normally used
      only for performance benefit, the TLS backend might not implement
      this function. Even if implemented, it may not actually succeed in
      allowing @conn to resume @source's TLS session, because the server
      may not have sent a session resumption token to @source, or it may
      refuse to accept the token from @conn. There is no way to know
      whether a call to this function is actually successful.

      Using this function is not required to benefit from session
      resumption. If the TLS backend supports session resumption, the
      session will be resumed automatically if it is possible to do so
      without weakening the privacy guarantees normally provided by TLS,
      without need to call this function. For example, with TLS 1.3,
      a session ticket will be automatically copied from any
      #GTlsClientConnection that has previously received session tickets
      from the server, provided a ticket is available that has not
      previously been used for session resumption, since session ticket
      reuse would be a privacy weakness. Using this function causes the
      ticket to be copied without regard for privacy considerations.
      Parameters:
      source - a #GTlsClientConnection

    • getAcceptedCas

      public List getAcceptedCas()
      Gets the list of distinguished names of the Certificate Authorities
      that the server will accept certificates from. This will be set
      during the TLS handshake if the server requests a certificate.
      Otherwise, it will be %NULL.

      Each item in the list is a #GByteArray which contains the complete
      subject DN of the certificate authority.
      Returns:
      the list of CA DNs. You should unref each element with g_byte_array_unref() and then the free the list with g_list_free().

    • getServerIdentity

      public SocketConnectable getServerIdentity()
      Gets @conn's expected server identity
      Returns:
      a #GSocketConnectable describing the expected server identity, or %NULL if the expected identity is not known.

    • setServerIdentity

      public void setServerIdentity(@Nonnull SocketConnectable identity)
      Sets @conn's expected server identity, which is used both to tell
      servers on virtual hosts which certificate to present, and also
      to let @conn know what name to look for in the certificate when
      performing %G_TLS_CERTIFICATE_BAD_IDENTITY validation, if enabled.
      Parameters:
      identity - a #GSocketConnectable describing the expected server identity

    • _new

      public static TlsClientConnection _new(@Nonnull IOStream base_io_stream, @Nullable SocketConnectable server_identity) throws AllocationError
      Creates a new #GTlsClientConnection wrapping @base_io_stream (which
      must have pollable input and output streams) which is assumed to
      communicate with the server identified by @server_identity.

      See the documentation for #GTlsConnection:base-io-stream for restrictions
      on when application code can run operations on the @base_io_stream after
      this function has returned.
      Parameters:
      base_io_stream - the #GIOStream to wrap
      server_identity - the expected identity of the server
      Returns:
      the new #GTlsClientConnection, or %NULL on error
      Throws:
      AllocationError

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()