gi-gio-2.0.20: GI/Gio/Interfaces/DtlsConnection.hs
{- |
Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte
License : LGPL-2.1
Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc)
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' is the base DTLS connection class type, which wraps
a 'GI.Gio.Interfaces.DatagramBased.DatagramBased' and provides DTLS encryption on top of it. Its
subclasses, 'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection' and 'GI.Gio.Interfaces.DtlsServerConnection.DtlsServerConnection',
implement client-side and server-side DTLS, respectively.
For TLS support, see 'GI.Gio.Objects.TlsConnection.TlsConnection'.
As DTLS is datagram based, 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' implements 'GI.Gio.Interfaces.DatagramBased.DatagramBased',
presenting a datagram-socket-like API for the encrypted connection. This
operates over a base datagram connection, which is also a 'GI.Gio.Interfaces.DatagramBased.DatagramBased'
('GI.Gio.Interfaces.DtlsConnection.DtlsConnection':@/base-socket/@).
To close a DTLS connection, use 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose'.
Neither 'GI.Gio.Interfaces.DtlsServerConnection.DtlsServerConnection' or 'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection' set the peer address
on their base 'GI.Gio.Interfaces.DatagramBased.DatagramBased' if it is a 'GI.Gio.Objects.Socket.Socket' — it is up to the caller to
do that if they wish. If they do not, and 'GI.Gio.Objects.Socket.socketClose' is called on the
base socket, the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' will not raise a 'GI.Gio.Enums.IOErrorEnumNotConnected'
error on further I\/O.
/Since: 2.48/
-}
#define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \
&& !defined(__HADDOCK_VERSION__))
module GI.Gio.Interfaces.DtlsConnection
(
-- * Exported types
DtlsConnection(..) ,
noDtlsConnection ,
IsDtlsConnection ,
toDtlsConnection ,
-- * Methods
-- ** close #method:close#
#if ENABLE_OVERLOADING
DtlsConnectionCloseMethodInfo ,
#endif
dtlsConnectionClose ,
-- ** closeAsync #method:closeAsync#
#if ENABLE_OVERLOADING
DtlsConnectionCloseAsyncMethodInfo ,
#endif
dtlsConnectionCloseAsync ,
-- ** closeFinish #method:closeFinish#
#if ENABLE_OVERLOADING
DtlsConnectionCloseFinishMethodInfo ,
#endif
dtlsConnectionCloseFinish ,
-- ** emitAcceptCertificate #method:emitAcceptCertificate#
#if ENABLE_OVERLOADING
DtlsConnectionEmitAcceptCertificateMethodInfo,
#endif
dtlsConnectionEmitAcceptCertificate ,
-- ** getCertificate #method:getCertificate#
#if ENABLE_OVERLOADING
DtlsConnectionGetCertificateMethodInfo ,
#endif
dtlsConnectionGetCertificate ,
-- ** getDatabase #method:getDatabase#
#if ENABLE_OVERLOADING
DtlsConnectionGetDatabaseMethodInfo ,
#endif
dtlsConnectionGetDatabase ,
-- ** getInteraction #method:getInteraction#
#if ENABLE_OVERLOADING
DtlsConnectionGetInteractionMethodInfo ,
#endif
dtlsConnectionGetInteraction ,
-- ** getNegotiatedProtocol #method:getNegotiatedProtocol#
#if ENABLE_OVERLOADING
DtlsConnectionGetNegotiatedProtocolMethodInfo,
#endif
dtlsConnectionGetNegotiatedProtocol ,
-- ** getPeerCertificate #method:getPeerCertificate#
#if ENABLE_OVERLOADING
DtlsConnectionGetPeerCertificateMethodInfo,
#endif
dtlsConnectionGetPeerCertificate ,
-- ** getPeerCertificateErrors #method:getPeerCertificateErrors#
#if ENABLE_OVERLOADING
DtlsConnectionGetPeerCertificateErrorsMethodInfo,
#endif
dtlsConnectionGetPeerCertificateErrors ,
-- ** getRehandshakeMode #method:getRehandshakeMode#
#if ENABLE_OVERLOADING
DtlsConnectionGetRehandshakeModeMethodInfo,
#endif
dtlsConnectionGetRehandshakeMode ,
-- ** getRequireCloseNotify #method:getRequireCloseNotify#
#if ENABLE_OVERLOADING
DtlsConnectionGetRequireCloseNotifyMethodInfo,
#endif
dtlsConnectionGetRequireCloseNotify ,
-- ** handshake #method:handshake#
#if ENABLE_OVERLOADING
DtlsConnectionHandshakeMethodInfo ,
#endif
dtlsConnectionHandshake ,
-- ** handshakeAsync #method:handshakeAsync#
#if ENABLE_OVERLOADING
DtlsConnectionHandshakeAsyncMethodInfo ,
#endif
dtlsConnectionHandshakeAsync ,
-- ** handshakeFinish #method:handshakeFinish#
#if ENABLE_OVERLOADING
DtlsConnectionHandshakeFinishMethodInfo ,
#endif
dtlsConnectionHandshakeFinish ,
-- ** setAdvertisedProtocols #method:setAdvertisedProtocols#
#if ENABLE_OVERLOADING
DtlsConnectionSetAdvertisedProtocolsMethodInfo,
#endif
dtlsConnectionSetAdvertisedProtocols ,
-- ** setCertificate #method:setCertificate#
#if ENABLE_OVERLOADING
DtlsConnectionSetCertificateMethodInfo ,
#endif
dtlsConnectionSetCertificate ,
-- ** setDatabase #method:setDatabase#
#if ENABLE_OVERLOADING
DtlsConnectionSetDatabaseMethodInfo ,
#endif
dtlsConnectionSetDatabase ,
-- ** setInteraction #method:setInteraction#
#if ENABLE_OVERLOADING
DtlsConnectionSetInteractionMethodInfo ,
#endif
dtlsConnectionSetInteraction ,
-- ** setRehandshakeMode #method:setRehandshakeMode#
#if ENABLE_OVERLOADING
DtlsConnectionSetRehandshakeModeMethodInfo,
#endif
dtlsConnectionSetRehandshakeMode ,
-- ** setRequireCloseNotify #method:setRequireCloseNotify#
#if ENABLE_OVERLOADING
DtlsConnectionSetRequireCloseNotifyMethodInfo,
#endif
dtlsConnectionSetRequireCloseNotify ,
-- ** shutdown #method:shutdown#
#if ENABLE_OVERLOADING
DtlsConnectionShutdownMethodInfo ,
#endif
dtlsConnectionShutdown ,
-- ** shutdownAsync #method:shutdownAsync#
#if ENABLE_OVERLOADING
DtlsConnectionShutdownAsyncMethodInfo ,
#endif
dtlsConnectionShutdownAsync ,
-- ** shutdownFinish #method:shutdownFinish#
#if ENABLE_OVERLOADING
DtlsConnectionShutdownFinishMethodInfo ,
#endif
dtlsConnectionShutdownFinish ,
-- * Properties
-- ** advertisedProtocols #attr:advertisedProtocols#
{- | The list of application-layer protocols that the connection
advertises that it is willing to speak. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetAdvertisedProtocols'.
/Since: 2.60/
-}
#if ENABLE_OVERLOADING
DtlsConnectionAdvertisedProtocolsPropertyInfo,
#endif
clearDtlsConnectionAdvertisedProtocols ,
constructDtlsConnectionAdvertisedProtocols,
#if ENABLE_OVERLOADING
dtlsConnectionAdvertisedProtocols ,
#endif
getDtlsConnectionAdvertisedProtocols ,
setDtlsConnectionAdvertisedProtocols ,
-- ** baseSocket #attr:baseSocket#
{- | The 'GI.Gio.Interfaces.DatagramBased.DatagramBased' that the connection wraps. Note that this may be any
implementation of 'GI.Gio.Interfaces.DatagramBased.DatagramBased', not just a 'GI.Gio.Objects.Socket.Socket'.
/Since: 2.48/
-}
#if ENABLE_OVERLOADING
DtlsConnectionBaseSocketPropertyInfo ,
#endif
constructDtlsConnectionBaseSocket ,
#if ENABLE_OVERLOADING
dtlsConnectionBaseSocket ,
#endif
getDtlsConnectionBaseSocket ,
-- ** certificate #attr:certificate#
{- | The connection\'s certificate; see
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetCertificate'.
/Since: 2.48/
-}
#if ENABLE_OVERLOADING
DtlsConnectionCertificatePropertyInfo ,
#endif
constructDtlsConnectionCertificate ,
#if ENABLE_OVERLOADING
dtlsConnectionCertificate ,
#endif
getDtlsConnectionCertificate ,
setDtlsConnectionCertificate ,
-- ** database #attr: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 'GI.Gio.Interfaces.TlsBackend.tlsBackendGetDefaultDatabase'.
/Since: 2.48/
-}
#if ENABLE_OVERLOADING
DtlsConnectionDatabasePropertyInfo ,
#endif
constructDtlsConnectionDatabase ,
#if ENABLE_OVERLOADING
dtlsConnectionDatabase ,
#endif
getDtlsConnectionDatabase ,
setDtlsConnectionDatabase ,
-- ** interaction #attr:interaction#
{- | A 'GI.Gio.Objects.TlsInteraction.TlsInteraction' object to be used when the connection or certificate
database need to interact with the user. This will be used to prompt the
user for passwords where necessary.
/Since: 2.48/
-}
#if ENABLE_OVERLOADING
DtlsConnectionInteractionPropertyInfo ,
#endif
clearDtlsConnectionInteraction ,
constructDtlsConnectionInteraction ,
#if ENABLE_OVERLOADING
dtlsConnectionInteraction ,
#endif
getDtlsConnectionInteraction ,
setDtlsConnectionInteraction ,
-- ** negotiatedProtocol #attr:negotiatedProtocol#
{- | The application-layer protocol negotiated during the TLS
handshake. See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionGetNegotiatedProtocol'.
/Since: 2.60/
-}
#if ENABLE_OVERLOADING
DtlsConnectionNegotiatedProtocolPropertyInfo,
#endif
#if ENABLE_OVERLOADING
dtlsConnectionNegotiatedProtocol ,
#endif
getDtlsConnectionNegotiatedProtocol ,
-- ** peerCertificate #attr:peerCertificate#
{- | The connection\'s peer\'s certificate, after the TLS handshake has
completed and the certificate has been accepted. Note in
particular that this is not yet set during the emission of
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@.
(You can watch for a 'GI.GObject.Objects.Object.Object'::@/notify/@ signal on this property to
detect when a handshake has occurred.)
/Since: 2.48/
-}
#if ENABLE_OVERLOADING
DtlsConnectionPeerCertificatePropertyInfo,
#endif
#if ENABLE_OVERLOADING
dtlsConnectionPeerCertificate ,
#endif
getDtlsConnectionPeerCertificate ,
-- ** peerCertificateErrors #attr:peerCertificateErrors#
{- | The errors noticed-and-ignored while verifying
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection':@/peer-certificate/@. Normally this should be 0, but
it may not be if 'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection':@/validation-flags/@ is not
'GI.Gio.Flags.TlsCertificateFlagsValidateAll', or if
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@ overrode the default
behavior.
/Since: 2.48/
-}
#if ENABLE_OVERLOADING
DtlsConnectionPeerCertificateErrorsPropertyInfo,
#endif
#if ENABLE_OVERLOADING
dtlsConnectionPeerCertificateErrors ,
#endif
getDtlsConnectionPeerCertificateErrors ,
-- ** rehandshakeMode #attr:rehandshakeMode#
{- | The rehandshaking mode. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRehandshakeMode'.
/Since: 2.48/
-}
#if ENABLE_OVERLOADING
DtlsConnectionRehandshakeModePropertyInfo,
#endif
constructDtlsConnectionRehandshakeMode ,
#if ENABLE_OVERLOADING
dtlsConnectionRehandshakeMode ,
#endif
getDtlsConnectionRehandshakeMode ,
setDtlsConnectionRehandshakeMode ,
-- ** requireCloseNotify #attr:requireCloseNotify#
{- | Whether or not proper TLS close notification is required.
See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRequireCloseNotify'.
/Since: 2.48/
-}
#if ENABLE_OVERLOADING
DtlsConnectionRequireCloseNotifyPropertyInfo,
#endif
constructDtlsConnectionRequireCloseNotify,
#if ENABLE_OVERLOADING
dtlsConnectionRequireCloseNotify ,
#endif
getDtlsConnectionRequireCloseNotify ,
setDtlsConnectionRequireCloseNotify ,
-- * Signals
-- ** acceptCertificate #signal:acceptCertificate#
C_DtlsConnectionAcceptCertificateCallback,
DtlsConnectionAcceptCertificateCallback ,
#if ENABLE_OVERLOADING
DtlsConnectionAcceptCertificateSignalInfo,
#endif
afterDtlsConnectionAcceptCertificate ,
genClosure_DtlsConnectionAcceptCertificate,
mk_DtlsConnectionAcceptCertificateCallback,
noDtlsConnectionAcceptCertificateCallback,
onDtlsConnectionAcceptCertificate ,
wrap_DtlsConnectionAcceptCertificateCallback,
) where
import Data.GI.Base.ShortPrelude
import qualified Data.GI.Base.ShortPrelude as SP
import qualified Data.GI.Base.Overloading as O
import qualified Prelude as P
import qualified Data.GI.Base.Attributes as GI.Attributes
import qualified Data.GI.Base.ManagedPtr as B.ManagedPtr
import qualified Data.GI.Base.GClosure as B.GClosure
import qualified Data.GI.Base.GError as B.GError
import qualified Data.GI.Base.GVariant as B.GVariant
import qualified Data.GI.Base.GValue as B.GValue
import qualified Data.GI.Base.GParamSpec as B.GParamSpec
import qualified Data.GI.Base.CallStack as B.CallStack
import qualified Data.GI.Base.Properties as B.Properties
import qualified Data.Text as T
import qualified Data.ByteString.Char8 as B
import qualified Data.Map as Map
import qualified Foreign.Ptr as FP
import qualified GHC.OverloadedLabels as OL
import qualified GI.GObject.Objects.Object as GObject.Object
import qualified GI.Gio.Callbacks as Gio.Callbacks
import {-# SOURCE #-} qualified GI.Gio.Enums as Gio.Enums
import {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags
import {-# SOURCE #-} qualified GI.Gio.Interfaces.AsyncResult as Gio.AsyncResult
import {-# SOURCE #-} qualified GI.Gio.Interfaces.DatagramBased as Gio.DatagramBased
import {-# SOURCE #-} qualified GI.Gio.Objects.Cancellable as Gio.Cancellable
import {-# SOURCE #-} qualified GI.Gio.Objects.TlsCertificate as Gio.TlsCertificate
import {-# SOURCE #-} qualified GI.Gio.Objects.TlsDatabase as Gio.TlsDatabase
import {-# SOURCE #-} qualified GI.Gio.Objects.TlsInteraction as Gio.TlsInteraction
-- interface DtlsConnection
-- | Memory-managed wrapper type.
newtype DtlsConnection = DtlsConnection (ManagedPtr DtlsConnection)
-- | A convenience alias for `Nothing` :: `Maybe` `DtlsConnection`.
noDtlsConnection :: Maybe DtlsConnection
noDtlsConnection = Nothing
-- signal DtlsConnection::accept-certificate
{- |
Emitted during the TLS handshake after the peer certificate has
been received. You can examine /@peerCert@/\'s certification path by
calling 'GI.Gio.Objects.TlsCertificate.tlsCertificateGetIssuer' on it.
For a client-side connection, /@peerCert@/ is the server\'s
certificate, and the signal will only be emitted if the
certificate was not acceptable according to /@conn@/\'s
'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection':@/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 'GI.Gio.Enums.TlsErrorBadCertificate'.
For a server-side connection, /@peerCert@/ is the certificate
presented by the client, if this was requested via the server\'s
'GI.Gio.Interfaces.DtlsServerConnection.DtlsServerConnection':@/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
'GI.Gio.Enums.TlsErrorBadCertificate', 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.
/Since: 2.48/
-}
type DtlsConnectionAcceptCertificateCallback =
Gio.TlsCertificate.TlsCertificate
{- ^ /@peerCert@/: the peer\'s 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -}
-> [Gio.Flags.TlsCertificateFlags]
{- ^ /@errors@/: the problems with /@peerCert@/. -}
-> IO Bool
{- ^ __Returns:__ 'True' to accept /@peerCert@/ (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. -}
-- | A convenience synonym for @`Nothing` :: `Maybe` `DtlsConnectionAcceptCertificateCallback`@.
noDtlsConnectionAcceptCertificateCallback :: Maybe DtlsConnectionAcceptCertificateCallback
noDtlsConnectionAcceptCertificateCallback = Nothing
-- | Type for the callback on the (unwrapped) C side.
type C_DtlsConnectionAcceptCertificateCallback =
Ptr () -> -- object
Ptr Gio.TlsCertificate.TlsCertificate ->
CUInt ->
Ptr () -> -- user_data
IO CInt
-- | Generate a function pointer callable from C code, from a `C_DtlsConnectionAcceptCertificateCallback`.
foreign import ccall "wrapper"
mk_DtlsConnectionAcceptCertificateCallback :: C_DtlsConnectionAcceptCertificateCallback -> IO (FunPtr C_DtlsConnectionAcceptCertificateCallback)
-- | Wrap the callback into a `GClosure`.
genClosure_DtlsConnectionAcceptCertificate :: MonadIO m => DtlsConnectionAcceptCertificateCallback -> m (GClosure C_DtlsConnectionAcceptCertificateCallback)
genClosure_DtlsConnectionAcceptCertificate cb = liftIO $ do
let cb' = wrap_DtlsConnectionAcceptCertificateCallback cb
mk_DtlsConnectionAcceptCertificateCallback cb' >>= B.GClosure.newGClosure
-- | Wrap a `DtlsConnectionAcceptCertificateCallback` into a `C_DtlsConnectionAcceptCertificateCallback`.
wrap_DtlsConnectionAcceptCertificateCallback ::
DtlsConnectionAcceptCertificateCallback ->
C_DtlsConnectionAcceptCertificateCallback
wrap_DtlsConnectionAcceptCertificateCallback _cb _ peerCert errors _ = do
peerCert' <- (newObject Gio.TlsCertificate.TlsCertificate) peerCert
let errors' = wordToGFlags errors
result <- _cb peerCert' errors'
let result' = (fromIntegral . fromEnum) result
return result'
{- |
Connect a signal handler for the “@accept-certificate@” signal, to be run before the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Signals.on' dtlsConnection #acceptCertificate callback
@
-}
onDtlsConnectionAcceptCertificate :: (IsDtlsConnection a, MonadIO m) => a -> DtlsConnectionAcceptCertificateCallback -> m SignalHandlerId
onDtlsConnectionAcceptCertificate obj cb = liftIO $ do
let cb' = wrap_DtlsConnectionAcceptCertificateCallback cb
cb'' <- mk_DtlsConnectionAcceptCertificateCallback cb'
connectSignalFunPtr obj "accept-certificate" cb'' SignalConnectBefore
{- |
Connect a signal handler for the “@accept-certificate@” signal, to be run after the default handler.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Signals.after' dtlsConnection #acceptCertificate callback
@
-}
afterDtlsConnectionAcceptCertificate :: (IsDtlsConnection a, MonadIO m) => a -> DtlsConnectionAcceptCertificateCallback -> m SignalHandlerId
afterDtlsConnectionAcceptCertificate obj cb = liftIO $ do
let cb' = wrap_DtlsConnectionAcceptCertificateCallback cb
cb'' <- mk_DtlsConnectionAcceptCertificateCallback cb'
connectSignalFunPtr obj "accept-certificate" cb'' SignalConnectAfter
#if ENABLE_OVERLOADING
data DtlsConnectionAcceptCertificateSignalInfo
instance SignalInfo DtlsConnectionAcceptCertificateSignalInfo where
type HaskellCallbackType DtlsConnectionAcceptCertificateSignalInfo = DtlsConnectionAcceptCertificateCallback
connectSignal _ obj cb connectMode = do
let cb' = wrap_DtlsConnectionAcceptCertificateCallback cb
cb'' <- mk_DtlsConnectionAcceptCertificateCallback cb'
connectSignalFunPtr obj "accept-certificate" cb'' connectMode
type instance O.SignalList DtlsConnection = DtlsConnectionSignalList
type DtlsConnectionSignalList = ('[ '("acceptCertificate", DtlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)])
#endif
foreign import ccall "g_dtls_connection_get_type"
c_g_dtls_connection_get_type :: IO GType
instance GObject DtlsConnection where
gobjectType = c_g_dtls_connection_get_type
-- | Type class for types which can be safely cast to `DtlsConnection`, for instance with `toDtlsConnection`.
class (GObject o, O.IsDescendantOf DtlsConnection o) => IsDtlsConnection o
instance (GObject o, O.IsDescendantOf DtlsConnection o) => IsDtlsConnection o
instance O.HasParentTypes DtlsConnection
type instance O.ParentTypes DtlsConnection = '[Gio.DatagramBased.DatagramBased, GObject.Object.Object]
-- | Cast to `DtlsConnection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`.
toDtlsConnection :: (MonadIO m, IsDtlsConnection o) => o -> m DtlsConnection
toDtlsConnection = liftIO . unsafeCastTo DtlsConnection
-- VVV Prop "advertised-protocols"
-- Type: TCArray True (-1) (-1) (TBasicType TUTF8)
-- Flags: [PropertyReadable,PropertyWritable]
-- Nullable: (Nothing,Just True)
{- |
Get the value of the “@advertised-protocols@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #advertisedProtocols
@
-}
getDtlsConnectionAdvertisedProtocols :: (MonadIO m, IsDtlsConnection o) => o -> m (Maybe [T.Text])
getDtlsConnectionAdvertisedProtocols obj = liftIO $ B.Properties.getObjectPropertyStringArray obj "advertised-protocols"
{- |
Set the value of the “@advertised-protocols@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' dtlsConnection [ #advertisedProtocols 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDtlsConnectionAdvertisedProtocols :: (MonadIO m, IsDtlsConnection o) => o -> [T.Text] -> m ()
setDtlsConnectionAdvertisedProtocols obj val = liftIO $ B.Properties.setObjectPropertyStringArray obj "advertised-protocols" (Just val)
{- |
Construct a `GValueConstruct` with valid value for the “@advertised-protocols@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDtlsConnectionAdvertisedProtocols :: (IsDtlsConnection o) => [T.Text] -> IO (GValueConstruct o)
constructDtlsConnectionAdvertisedProtocols val = B.Properties.constructObjectPropertyStringArray "advertised-protocols" (Just val)
{- |
Set the value of the “@advertised-protocols@” property to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.clear' #advertisedProtocols
@
-}
clearDtlsConnectionAdvertisedProtocols :: (MonadIO m, IsDtlsConnection o) => o -> m ()
clearDtlsConnectionAdvertisedProtocols obj = liftIO $ B.Properties.setObjectPropertyStringArray obj "advertised-protocols" (Nothing :: Maybe [T.Text])
#if ENABLE_OVERLOADING
data DtlsConnectionAdvertisedProtocolsPropertyInfo
instance AttrInfo DtlsConnectionAdvertisedProtocolsPropertyInfo where
type AttrAllowedOps DtlsConnectionAdvertisedProtocolsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DtlsConnectionAdvertisedProtocolsPropertyInfo = (~) [T.Text]
type AttrBaseTypeConstraint DtlsConnectionAdvertisedProtocolsPropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionAdvertisedProtocolsPropertyInfo = (Maybe [T.Text])
type AttrLabel DtlsConnectionAdvertisedProtocolsPropertyInfo = "advertised-protocols"
type AttrOrigin DtlsConnectionAdvertisedProtocolsPropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionAdvertisedProtocols
attrSet _ = setDtlsConnectionAdvertisedProtocols
attrConstruct _ = constructDtlsConnectionAdvertisedProtocols
attrClear _ = clearDtlsConnectionAdvertisedProtocols
#endif
-- VVV Prop "base-socket"
-- Type: TInterface (Name {namespace = "Gio", name = "DatagramBased"})
-- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly]
-- Nullable: (Nothing,Nothing)
{- |
Get the value of the “@base-socket@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #baseSocket
@
-}
getDtlsConnectionBaseSocket :: (MonadIO m, IsDtlsConnection o) => o -> m (Maybe Gio.DatagramBased.DatagramBased)
getDtlsConnectionBaseSocket obj = liftIO $ B.Properties.getObjectPropertyObject obj "base-socket" Gio.DatagramBased.DatagramBased
{- |
Construct a `GValueConstruct` with valid value for the “@base-socket@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDtlsConnectionBaseSocket :: (IsDtlsConnection o, Gio.DatagramBased.IsDatagramBased a) => a -> IO (GValueConstruct o)
constructDtlsConnectionBaseSocket val = B.Properties.constructObjectPropertyObject "base-socket" (Just val)
#if ENABLE_OVERLOADING
data DtlsConnectionBaseSocketPropertyInfo
instance AttrInfo DtlsConnectionBaseSocketPropertyInfo where
type AttrAllowedOps DtlsConnectionBaseSocketPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DtlsConnectionBaseSocketPropertyInfo = Gio.DatagramBased.IsDatagramBased
type AttrBaseTypeConstraint DtlsConnectionBaseSocketPropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionBaseSocketPropertyInfo = (Maybe Gio.DatagramBased.DatagramBased)
type AttrLabel DtlsConnectionBaseSocketPropertyInfo = "base-socket"
type AttrOrigin DtlsConnectionBaseSocketPropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionBaseSocket
attrSet _ = undefined
attrConstruct _ = constructDtlsConnectionBaseSocket
attrClear _ = undefined
#endif
-- VVV Prop "certificate"
-- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
-- Flags: [PropertyReadable,PropertyWritable]
-- Nullable: (Just False,Just False)
{- |
Get the value of the “@certificate@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #certificate
@
-}
getDtlsConnectionCertificate :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.TlsCertificate.TlsCertificate
getDtlsConnectionCertificate obj = liftIO $ checkUnexpectedNothing "getDtlsConnectionCertificate" $ B.Properties.getObjectPropertyObject obj "certificate" Gio.TlsCertificate.TlsCertificate
{- |
Set the value of the “@certificate@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' dtlsConnection [ #certificate 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDtlsConnectionCertificate :: (MonadIO m, IsDtlsConnection o, Gio.TlsCertificate.IsTlsCertificate a) => o -> a -> m ()
setDtlsConnectionCertificate obj val = liftIO $ B.Properties.setObjectPropertyObject obj "certificate" (Just val)
{- |
Construct a `GValueConstruct` with valid value for the “@certificate@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDtlsConnectionCertificate :: (IsDtlsConnection o, Gio.TlsCertificate.IsTlsCertificate a) => a -> IO (GValueConstruct o)
constructDtlsConnectionCertificate val = B.Properties.constructObjectPropertyObject "certificate" (Just val)
#if ENABLE_OVERLOADING
data DtlsConnectionCertificatePropertyInfo
instance AttrInfo DtlsConnectionCertificatePropertyInfo where
type AttrAllowedOps DtlsConnectionCertificatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint DtlsConnectionCertificatePropertyInfo = Gio.TlsCertificate.IsTlsCertificate
type AttrBaseTypeConstraint DtlsConnectionCertificatePropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionCertificatePropertyInfo = Gio.TlsCertificate.TlsCertificate
type AttrLabel DtlsConnectionCertificatePropertyInfo = "certificate"
type AttrOrigin DtlsConnectionCertificatePropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionCertificate
attrSet _ = setDtlsConnectionCertificate
attrConstruct _ = constructDtlsConnectionCertificate
attrClear _ = undefined
#endif
-- VVV Prop "database"
-- Type: TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
-- Flags: [PropertyReadable,PropertyWritable]
-- Nullable: (Just False,Just False)
{- |
Get the value of the “@database@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #database
@
-}
getDtlsConnectionDatabase :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.TlsDatabase.TlsDatabase
getDtlsConnectionDatabase obj = liftIO $ checkUnexpectedNothing "getDtlsConnectionDatabase" $ B.Properties.getObjectPropertyObject obj "database" Gio.TlsDatabase.TlsDatabase
{- |
Set the value of the “@database@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' dtlsConnection [ #database 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDtlsConnectionDatabase :: (MonadIO m, IsDtlsConnection o, Gio.TlsDatabase.IsTlsDatabase a) => o -> a -> m ()
setDtlsConnectionDatabase obj val = liftIO $ B.Properties.setObjectPropertyObject obj "database" (Just val)
{- |
Construct a `GValueConstruct` with valid value for the “@database@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDtlsConnectionDatabase :: (IsDtlsConnection o, Gio.TlsDatabase.IsTlsDatabase a) => a -> IO (GValueConstruct o)
constructDtlsConnectionDatabase val = B.Properties.constructObjectPropertyObject "database" (Just val)
#if ENABLE_OVERLOADING
data DtlsConnectionDatabasePropertyInfo
instance AttrInfo DtlsConnectionDatabasePropertyInfo where
type AttrAllowedOps DtlsConnectionDatabasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint DtlsConnectionDatabasePropertyInfo = Gio.TlsDatabase.IsTlsDatabase
type AttrBaseTypeConstraint DtlsConnectionDatabasePropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionDatabasePropertyInfo = Gio.TlsDatabase.TlsDatabase
type AttrLabel DtlsConnectionDatabasePropertyInfo = "database"
type AttrOrigin DtlsConnectionDatabasePropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionDatabase
attrSet _ = setDtlsConnectionDatabase
attrConstruct _ = constructDtlsConnectionDatabase
attrClear _ = undefined
#endif
-- VVV Prop "interaction"
-- Type: TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
-- Flags: [PropertyReadable,PropertyWritable]
-- Nullable: (Just False,Just True)
{- |
Get the value of the “@interaction@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #interaction
@
-}
getDtlsConnectionInteraction :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.TlsInteraction.TlsInteraction
getDtlsConnectionInteraction obj = liftIO $ checkUnexpectedNothing "getDtlsConnectionInteraction" $ B.Properties.getObjectPropertyObject obj "interaction" Gio.TlsInteraction.TlsInteraction
{- |
Set the value of the “@interaction@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' dtlsConnection [ #interaction 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDtlsConnectionInteraction :: (MonadIO m, IsDtlsConnection o, Gio.TlsInteraction.IsTlsInteraction a) => o -> a -> m ()
setDtlsConnectionInteraction obj val = liftIO $ B.Properties.setObjectPropertyObject obj "interaction" (Just val)
{- |
Construct a `GValueConstruct` with valid value for the “@interaction@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDtlsConnectionInteraction :: (IsDtlsConnection o, Gio.TlsInteraction.IsTlsInteraction a) => a -> IO (GValueConstruct o)
constructDtlsConnectionInteraction val = B.Properties.constructObjectPropertyObject "interaction" (Just val)
{- |
Set the value of the “@interaction@” property to `Nothing`.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.clear' #interaction
@
-}
clearDtlsConnectionInteraction :: (MonadIO m, IsDtlsConnection o) => o -> m ()
clearDtlsConnectionInteraction obj = liftIO $ B.Properties.setObjectPropertyObject obj "interaction" (Nothing :: Maybe Gio.TlsInteraction.TlsInteraction)
#if ENABLE_OVERLOADING
data DtlsConnectionInteractionPropertyInfo
instance AttrInfo DtlsConnectionInteractionPropertyInfo where
type AttrAllowedOps DtlsConnectionInteractionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DtlsConnectionInteractionPropertyInfo = Gio.TlsInteraction.IsTlsInteraction
type AttrBaseTypeConstraint DtlsConnectionInteractionPropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionInteractionPropertyInfo = Gio.TlsInteraction.TlsInteraction
type AttrLabel DtlsConnectionInteractionPropertyInfo = "interaction"
type AttrOrigin DtlsConnectionInteractionPropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionInteraction
attrSet _ = setDtlsConnectionInteraction
attrConstruct _ = constructDtlsConnectionInteraction
attrClear _ = clearDtlsConnectionInteraction
#endif
-- VVV Prop "negotiated-protocol"
-- Type: TBasicType TUTF8
-- Flags: [PropertyReadable]
-- Nullable: (Just True,Nothing)
{- |
Get the value of the “@negotiated-protocol@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #negotiatedProtocol
@
-}
getDtlsConnectionNegotiatedProtocol :: (MonadIO m, IsDtlsConnection o) => o -> m (Maybe T.Text)
getDtlsConnectionNegotiatedProtocol obj = liftIO $ B.Properties.getObjectPropertyString obj "negotiated-protocol"
#if ENABLE_OVERLOADING
data DtlsConnectionNegotiatedProtocolPropertyInfo
instance AttrInfo DtlsConnectionNegotiatedProtocolPropertyInfo where
type AttrAllowedOps DtlsConnectionNegotiatedProtocolPropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DtlsConnectionNegotiatedProtocolPropertyInfo = (~) ()
type AttrBaseTypeConstraint DtlsConnectionNegotiatedProtocolPropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionNegotiatedProtocolPropertyInfo = (Maybe T.Text)
type AttrLabel DtlsConnectionNegotiatedProtocolPropertyInfo = "negotiated-protocol"
type AttrOrigin DtlsConnectionNegotiatedProtocolPropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionNegotiatedProtocol
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
-- VVV Prop "peer-certificate"
-- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
-- Flags: [PropertyReadable]
-- Nullable: (Just False,Nothing)
{- |
Get the value of the “@peer-certificate@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #peerCertificate
@
-}
getDtlsConnectionPeerCertificate :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.TlsCertificate.TlsCertificate
getDtlsConnectionPeerCertificate obj = liftIO $ checkUnexpectedNothing "getDtlsConnectionPeerCertificate" $ B.Properties.getObjectPropertyObject obj "peer-certificate" Gio.TlsCertificate.TlsCertificate
#if ENABLE_OVERLOADING
data DtlsConnectionPeerCertificatePropertyInfo
instance AttrInfo DtlsConnectionPeerCertificatePropertyInfo where
type AttrAllowedOps DtlsConnectionPeerCertificatePropertyInfo = '[ 'AttrGet, 'AttrClear]
type AttrSetTypeConstraint DtlsConnectionPeerCertificatePropertyInfo = (~) ()
type AttrBaseTypeConstraint DtlsConnectionPeerCertificatePropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionPeerCertificatePropertyInfo = Gio.TlsCertificate.TlsCertificate
type AttrLabel DtlsConnectionPeerCertificatePropertyInfo = "peer-certificate"
type AttrOrigin DtlsConnectionPeerCertificatePropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionPeerCertificate
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
-- VVV Prop "peer-certificate-errors"
-- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"})
-- Flags: [PropertyReadable]
-- Nullable: (Just False,Nothing)
{- |
Get the value of the “@peer-certificate-errors@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #peerCertificateErrors
@
-}
getDtlsConnectionPeerCertificateErrors :: (MonadIO m, IsDtlsConnection o) => o -> m [Gio.Flags.TlsCertificateFlags]
getDtlsConnectionPeerCertificateErrors obj = liftIO $ B.Properties.getObjectPropertyFlags obj "peer-certificate-errors"
#if ENABLE_OVERLOADING
data DtlsConnectionPeerCertificateErrorsPropertyInfo
instance AttrInfo DtlsConnectionPeerCertificateErrorsPropertyInfo where
type AttrAllowedOps DtlsConnectionPeerCertificateErrorsPropertyInfo = '[ 'AttrGet]
type AttrSetTypeConstraint DtlsConnectionPeerCertificateErrorsPropertyInfo = (~) ()
type AttrBaseTypeConstraint DtlsConnectionPeerCertificateErrorsPropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionPeerCertificateErrorsPropertyInfo = [Gio.Flags.TlsCertificateFlags]
type AttrLabel DtlsConnectionPeerCertificateErrorsPropertyInfo = "peer-certificate-errors"
type AttrOrigin DtlsConnectionPeerCertificateErrorsPropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionPeerCertificateErrors
attrSet _ = undefined
attrConstruct _ = undefined
attrClear _ = undefined
#endif
-- VVV Prop "rehandshake-mode"
-- Type: TInterface (Name {namespace = "Gio", name = "TlsRehandshakeMode"})
-- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
-- Nullable: (Just False,Just False)
{- |
Get the value of the “@rehandshake-mode@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #rehandshakeMode
@
-}
getDtlsConnectionRehandshakeMode :: (MonadIO m, IsDtlsConnection o) => o -> m Gio.Enums.TlsRehandshakeMode
getDtlsConnectionRehandshakeMode obj = liftIO $ B.Properties.getObjectPropertyEnum obj "rehandshake-mode"
{- |
Set the value of the “@rehandshake-mode@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' dtlsConnection [ #rehandshakeMode 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDtlsConnectionRehandshakeMode :: (MonadIO m, IsDtlsConnection o) => o -> Gio.Enums.TlsRehandshakeMode -> m ()
setDtlsConnectionRehandshakeMode obj val = liftIO $ B.Properties.setObjectPropertyEnum obj "rehandshake-mode" val
{- |
Construct a `GValueConstruct` with valid value for the “@rehandshake-mode@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDtlsConnectionRehandshakeMode :: (IsDtlsConnection o) => Gio.Enums.TlsRehandshakeMode -> IO (GValueConstruct o)
constructDtlsConnectionRehandshakeMode val = B.Properties.constructObjectPropertyEnum "rehandshake-mode" val
#if ENABLE_OVERLOADING
data DtlsConnectionRehandshakeModePropertyInfo
instance AttrInfo DtlsConnectionRehandshakeModePropertyInfo where
type AttrAllowedOps DtlsConnectionRehandshakeModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint DtlsConnectionRehandshakeModePropertyInfo = (~) Gio.Enums.TlsRehandshakeMode
type AttrBaseTypeConstraint DtlsConnectionRehandshakeModePropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionRehandshakeModePropertyInfo = Gio.Enums.TlsRehandshakeMode
type AttrLabel DtlsConnectionRehandshakeModePropertyInfo = "rehandshake-mode"
type AttrOrigin DtlsConnectionRehandshakeModePropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionRehandshakeMode
attrSet _ = setDtlsConnectionRehandshakeMode
attrConstruct _ = constructDtlsConnectionRehandshakeMode
attrClear _ = undefined
#endif
-- VVV Prop "require-close-notify"
-- Type: TBasicType TBoolean
-- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct]
-- Nullable: (Just False,Just False)
{- |
Get the value of the “@require-close-notify@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.get' dtlsConnection #requireCloseNotify
@
-}
getDtlsConnectionRequireCloseNotify :: (MonadIO m, IsDtlsConnection o) => o -> m Bool
getDtlsConnectionRequireCloseNotify obj = liftIO $ B.Properties.getObjectPropertyBool obj "require-close-notify"
{- |
Set the value of the “@require-close-notify@” property.
When <https://github.com/haskell-gi/haskell-gi/wiki/Overloading overloading> is enabled, this is equivalent to
@
'Data.GI.Base.Attributes.set' dtlsConnection [ #requireCloseNotify 'Data.GI.Base.Attributes.:=' value ]
@
-}
setDtlsConnectionRequireCloseNotify :: (MonadIO m, IsDtlsConnection o) => o -> Bool -> m ()
setDtlsConnectionRequireCloseNotify obj val = liftIO $ B.Properties.setObjectPropertyBool obj "require-close-notify" val
{- |
Construct a `GValueConstruct` with valid value for the “@require-close-notify@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`.
-}
constructDtlsConnectionRequireCloseNotify :: (IsDtlsConnection o) => Bool -> IO (GValueConstruct o)
constructDtlsConnectionRequireCloseNotify val = B.Properties.constructObjectPropertyBool "require-close-notify" val
#if ENABLE_OVERLOADING
data DtlsConnectionRequireCloseNotifyPropertyInfo
instance AttrInfo DtlsConnectionRequireCloseNotifyPropertyInfo where
type AttrAllowedOps DtlsConnectionRequireCloseNotifyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet]
type AttrSetTypeConstraint DtlsConnectionRequireCloseNotifyPropertyInfo = (~) Bool
type AttrBaseTypeConstraint DtlsConnectionRequireCloseNotifyPropertyInfo = IsDtlsConnection
type AttrGetType DtlsConnectionRequireCloseNotifyPropertyInfo = Bool
type AttrLabel DtlsConnectionRequireCloseNotifyPropertyInfo = "require-close-notify"
type AttrOrigin DtlsConnectionRequireCloseNotifyPropertyInfo = DtlsConnection
attrGet _ = getDtlsConnectionRequireCloseNotify
attrSet _ = setDtlsConnectionRequireCloseNotify
attrConstruct _ = constructDtlsConnectionRequireCloseNotify
attrClear _ = undefined
#endif
#if ENABLE_OVERLOADING
instance O.HasAttributeList DtlsConnection
type instance O.AttributeList DtlsConnection = DtlsConnectionAttributeList
type DtlsConnectionAttributeList = ('[ '("advertisedProtocols", DtlsConnectionAdvertisedProtocolsPropertyInfo), '("baseSocket", DtlsConnectionBaseSocketPropertyInfo), '("certificate", DtlsConnectionCertificatePropertyInfo), '("database", DtlsConnectionDatabasePropertyInfo), '("interaction", DtlsConnectionInteractionPropertyInfo), '("negotiatedProtocol", DtlsConnectionNegotiatedProtocolPropertyInfo), '("peerCertificate", DtlsConnectionPeerCertificatePropertyInfo), '("peerCertificateErrors", DtlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshakeMode", DtlsConnectionRehandshakeModePropertyInfo), '("requireCloseNotify", DtlsConnectionRequireCloseNotifyPropertyInfo)] :: [(Symbol, *)])
#endif
#if ENABLE_OVERLOADING
dtlsConnectionAdvertisedProtocols :: AttrLabelProxy "advertisedProtocols"
dtlsConnectionAdvertisedProtocols = AttrLabelProxy
dtlsConnectionBaseSocket :: AttrLabelProxy "baseSocket"
dtlsConnectionBaseSocket = AttrLabelProxy
dtlsConnectionCertificate :: AttrLabelProxy "certificate"
dtlsConnectionCertificate = AttrLabelProxy
dtlsConnectionDatabase :: AttrLabelProxy "database"
dtlsConnectionDatabase = AttrLabelProxy
dtlsConnectionInteraction :: AttrLabelProxy "interaction"
dtlsConnectionInteraction = AttrLabelProxy
dtlsConnectionNegotiatedProtocol :: AttrLabelProxy "negotiatedProtocol"
dtlsConnectionNegotiatedProtocol = AttrLabelProxy
dtlsConnectionPeerCertificate :: AttrLabelProxy "peerCertificate"
dtlsConnectionPeerCertificate = AttrLabelProxy
dtlsConnectionPeerCertificateErrors :: AttrLabelProxy "peerCertificateErrors"
dtlsConnectionPeerCertificateErrors = AttrLabelProxy
dtlsConnectionRehandshakeMode :: AttrLabelProxy "rehandshakeMode"
dtlsConnectionRehandshakeMode = AttrLabelProxy
dtlsConnectionRequireCloseNotify :: AttrLabelProxy "requireCloseNotify"
dtlsConnectionRequireCloseNotify = AttrLabelProxy
#endif
#if ENABLE_OVERLOADING
type family ResolveDtlsConnectionMethod (t :: Symbol) (o :: *) :: * where
ResolveDtlsConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo
ResolveDtlsConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo
ResolveDtlsConnectionMethod "close" o = DtlsConnectionCloseMethodInfo
ResolveDtlsConnectionMethod "closeAsync" o = DtlsConnectionCloseAsyncMethodInfo
ResolveDtlsConnectionMethod "closeFinish" o = DtlsConnectionCloseFinishMethodInfo
ResolveDtlsConnectionMethod "conditionCheck" o = Gio.DatagramBased.DatagramBasedConditionCheckMethodInfo
ResolveDtlsConnectionMethod "conditionWait" o = Gio.DatagramBased.DatagramBasedConditionWaitMethodInfo
ResolveDtlsConnectionMethod "createSource" o = Gio.DatagramBased.DatagramBasedCreateSourceMethodInfo
ResolveDtlsConnectionMethod "emitAcceptCertificate" o = DtlsConnectionEmitAcceptCertificateMethodInfo
ResolveDtlsConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo
ResolveDtlsConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo
ResolveDtlsConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo
ResolveDtlsConnectionMethod "handshake" o = DtlsConnectionHandshakeMethodInfo
ResolveDtlsConnectionMethod "handshakeAsync" o = DtlsConnectionHandshakeAsyncMethodInfo
ResolveDtlsConnectionMethod "handshakeFinish" o = DtlsConnectionHandshakeFinishMethodInfo
ResolveDtlsConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo
ResolveDtlsConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo
ResolveDtlsConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo
ResolveDtlsConnectionMethod "receiveMessages" o = Gio.DatagramBased.DatagramBasedReceiveMessagesMethodInfo
ResolveDtlsConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo
ResolveDtlsConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo
ResolveDtlsConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo
ResolveDtlsConnectionMethod "sendMessages" o = Gio.DatagramBased.DatagramBasedSendMessagesMethodInfo
ResolveDtlsConnectionMethod "shutdown" o = DtlsConnectionShutdownMethodInfo
ResolveDtlsConnectionMethod "shutdownAsync" o = DtlsConnectionShutdownAsyncMethodInfo
ResolveDtlsConnectionMethod "shutdownFinish" o = DtlsConnectionShutdownFinishMethodInfo
ResolveDtlsConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo
ResolveDtlsConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo
ResolveDtlsConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo
ResolveDtlsConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo
ResolveDtlsConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo
ResolveDtlsConnectionMethod "getCertificate" o = DtlsConnectionGetCertificateMethodInfo
ResolveDtlsConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo
ResolveDtlsConnectionMethod "getDatabase" o = DtlsConnectionGetDatabaseMethodInfo
ResolveDtlsConnectionMethod "getInteraction" o = DtlsConnectionGetInteractionMethodInfo
ResolveDtlsConnectionMethod "getNegotiatedProtocol" o = DtlsConnectionGetNegotiatedProtocolMethodInfo
ResolveDtlsConnectionMethod "getPeerCertificate" o = DtlsConnectionGetPeerCertificateMethodInfo
ResolveDtlsConnectionMethod "getPeerCertificateErrors" o = DtlsConnectionGetPeerCertificateErrorsMethodInfo
ResolveDtlsConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo
ResolveDtlsConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo
ResolveDtlsConnectionMethod "getRehandshakeMode" o = DtlsConnectionGetRehandshakeModeMethodInfo
ResolveDtlsConnectionMethod "getRequireCloseNotify" o = DtlsConnectionGetRequireCloseNotifyMethodInfo
ResolveDtlsConnectionMethod "setAdvertisedProtocols" o = DtlsConnectionSetAdvertisedProtocolsMethodInfo
ResolveDtlsConnectionMethod "setCertificate" o = DtlsConnectionSetCertificateMethodInfo
ResolveDtlsConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo
ResolveDtlsConnectionMethod "setDatabase" o = DtlsConnectionSetDatabaseMethodInfo
ResolveDtlsConnectionMethod "setInteraction" o = DtlsConnectionSetInteractionMethodInfo
ResolveDtlsConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo
ResolveDtlsConnectionMethod "setRehandshakeMode" o = DtlsConnectionSetRehandshakeModeMethodInfo
ResolveDtlsConnectionMethod "setRequireCloseNotify" o = DtlsConnectionSetRequireCloseNotifyMethodInfo
ResolveDtlsConnectionMethod l o = O.MethodResolutionFailed l o
instance (info ~ ResolveDtlsConnectionMethod t DtlsConnection, O.MethodInfo info DtlsConnection p) => OL.IsLabel t (DtlsConnection -> p) where
#if MIN_VERSION_base(4,10,0)
fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#else
fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info)
#endif
#endif
-- method DtlsConnection::close
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False
foreign import ccall "g_dtls_connection_close" g_dtls_connection_close ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
Ptr (Ptr GError) -> -- error
IO CInt
{- |
Close the DTLS connection. This is equivalent to calling
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionShutdown' to shut down both sides of the connection.
Closing a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' 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 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection':@/base-socket/@; that must be closed
separately.
Once /@conn@/ is closed, all other operations will return 'GI.Gio.Enums.IOErrorEnumClosed'.
Closing a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' 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 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' may be left
partially-closed and any pending untransmitted data may be lost. Call
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose' again to complete closing the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'.
/Since: 2.48/
-}
dtlsConnectionClose ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Maybe (b)
{- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
-> m ()
{- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dtlsConnectionClose conn cancellable = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
onException (do
_ <- propagateGError $ g_dtls_connection_close conn' maybeCancellable
touchManagedPtr conn
whenJust cancellable touchManagedPtr
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data DtlsConnectionCloseMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionCloseMethodInfo a signature where
overloadedMethod _ = dtlsConnectionClose
#endif
-- method DtlsConnection::close_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the close operation is complete", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_close_async" g_dtls_connection_close_async ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Int32 -> -- io_priority : TBasicType TInt
Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
Ptr () -> -- user_data : TBasicType TPtr
IO ()
{- |
Asynchronously close the DTLS connection. See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose' for
more information.
/Since: 2.48/
-}
dtlsConnectionCloseAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Int32
{- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
-> Maybe (b)
{- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
{- ^ /@callback@/: callback to call when the close operation is complete -}
-> m ()
dtlsConnectionCloseAsync conn ioPriority cancellable callback = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
maybeCallback <- case callback of
Nothing -> return (castPtrToFunPtr nullPtr)
Just jCallback -> do
ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
poke ptrcallback jCallback'
return jCallback'
let userData = nullPtr
g_dtls_connection_close_async conn' ioPriority maybeCancellable maybeCallback userData
touchManagedPtr conn
whenJust cancellable touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionCloseAsyncMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionCloseAsyncMethodInfo a signature where
overloadedMethod _ = dtlsConnectionCloseAsync
#endif
-- method DtlsConnection::close_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False
foreign import ccall "g_dtls_connection_close_finish" g_dtls_connection_close_finish ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
Ptr (Ptr GError) -> -- error
IO CInt
{- |
Finish an asynchronous TLS close operation. See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose'
for more information.
/Since: 2.48/
-}
dtlsConnectionCloseFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> b
{- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
-> m ()
{- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dtlsConnectionCloseFinish conn result_ = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result_' <- unsafeManagedPtrCastPtr result_
onException (do
_ <- propagateGError $ g_dtls_connection_close_finish conn' result_'
touchManagedPtr conn
touchManagedPtr result_
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data DtlsConnectionCloseFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DtlsConnectionCloseFinishMethodInfo a signature where
overloadedMethod _ = dtlsConnectionCloseFinish
#endif
-- method DtlsConnection::emit_accept_certificate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "peer_cert", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the peer's #GTlsCertificate", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "errors", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the problems with @peer_cert", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_emit_accept_certificate" g_dtls_connection_emit_accept_certificate ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.TlsCertificate.TlsCertificate -> -- peer_cert : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
CUInt -> -- errors : TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"})
IO CInt
{- |
Used by 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' implementations to emit the
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@ signal.
/Since: 2.48/
-}
dtlsConnectionEmitAcceptCertificate ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> b
{- ^ /@peerCert@/: the peer\'s 'GI.Gio.Objects.TlsCertificate.TlsCertificate' -}
-> [Gio.Flags.TlsCertificateFlags]
{- ^ /@errors@/: the problems with /@peerCert@/ -}
-> m Bool
{- ^ __Returns:__ 'True' if one of the signal handlers has returned
'True' to accept /@peerCert@/ -}
dtlsConnectionEmitAcceptCertificate conn peerCert errors = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
peerCert' <- unsafeManagedPtrCastPtr peerCert
let errors' = gflagsToWord errors
result <- g_dtls_connection_emit_accept_certificate conn' peerCert' errors'
let result' = (/= 0) result
touchManagedPtr conn
touchManagedPtr peerCert
return result'
#if ENABLE_OVERLOADING
data DtlsConnectionEmitAcceptCertificateMethodInfo
instance (signature ~ (b -> [Gio.Flags.TlsCertificateFlags] -> m Bool), MonadIO m, IsDtlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo DtlsConnectionEmitAcceptCertificateMethodInfo a signature where
overloadedMethod _ = dtlsConnectionEmitAcceptCertificate
#endif
-- method DtlsConnection::get_certificate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificate"}))
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_get_certificate" g_dtls_connection_get_certificate ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
IO (Ptr Gio.TlsCertificate.TlsCertificate)
{- |
Gets /@conn@/\'s certificate, as set by
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetCertificate'.
/Since: 2.48/
-}
dtlsConnectionGetCertificate ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> m Gio.TlsCertificate.TlsCertificate
{- ^ __Returns:__ /@conn@/\'s certificate, or 'Nothing' -}
dtlsConnectionGetCertificate conn = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result <- g_dtls_connection_get_certificate conn'
checkUnexpectedReturnNULL "dtlsConnectionGetCertificate" result
result' <- (newObject Gio.TlsCertificate.TlsCertificate) result
touchManagedPtr conn
return result'
#if ENABLE_OVERLOADING
data DtlsConnectionGetCertificateMethodInfo
instance (signature ~ (m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetCertificateMethodInfo a signature where
overloadedMethod _ = dtlsConnectionGetCertificate
#endif
-- method DtlsConnection::get_database
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsDatabase"}))
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_get_database" g_dtls_connection_get_database ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
IO (Ptr Gio.TlsDatabase.TlsDatabase)
{- |
Gets the certificate database that /@conn@/ uses to verify
peer certificates. See 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetDatabase'.
/Since: 2.48/
-}
dtlsConnectionGetDatabase ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> m Gio.TlsDatabase.TlsDatabase
{- ^ __Returns:__ the certificate database that /@conn@/ uses or 'Nothing' -}
dtlsConnectionGetDatabase conn = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result <- g_dtls_connection_get_database conn'
checkUnexpectedReturnNULL "dtlsConnectionGetDatabase" result
result' <- (newObject Gio.TlsDatabase.TlsDatabase) result
touchManagedPtr conn
return result'
#if ENABLE_OVERLOADING
data DtlsConnectionGetDatabaseMethodInfo
instance (signature ~ (m Gio.TlsDatabase.TlsDatabase), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetDatabaseMethodInfo a signature where
overloadedMethod _ = dtlsConnectionGetDatabase
#endif
-- method DtlsConnection::get_interaction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsInteraction"}))
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_get_interaction" g_dtls_connection_get_interaction ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
IO (Ptr Gio.TlsInteraction.TlsInteraction)
{- |
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 'Nothing' is returned, then
no user interaction will occur for this connection.
/Since: 2.48/
-}
dtlsConnectionGetInteraction ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a connection -}
-> m Gio.TlsInteraction.TlsInteraction
{- ^ __Returns:__ The interaction object. -}
dtlsConnectionGetInteraction conn = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result <- g_dtls_connection_get_interaction conn'
checkUnexpectedReturnNULL "dtlsConnectionGetInteraction" result
result' <- (newObject Gio.TlsInteraction.TlsInteraction) result
touchManagedPtr conn
return result'
#if ENABLE_OVERLOADING
data DtlsConnectionGetInteractionMethodInfo
instance (signature ~ (m Gio.TlsInteraction.TlsInteraction), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetInteractionMethodInfo a signature where
overloadedMethod _ = dtlsConnectionGetInteraction
#endif
-- method DtlsConnection::get_negotiated_protocol
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TUTF8)
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_get_negotiated_protocol" g_dtls_connection_get_negotiated_protocol ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
IO CString
{- |
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 'Nothing'. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetAdvertisedProtocols'.
/Since: 2.60/
-}
dtlsConnectionGetNegotiatedProtocol ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> m (Maybe T.Text)
{- ^ __Returns:__ the negotiated protocol, or 'Nothing' -}
dtlsConnectionGetNegotiatedProtocol conn = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result <- g_dtls_connection_get_negotiated_protocol conn'
maybeResult <- convertIfNonNull result $ \result' -> do
result'' <- cstringToText result'
return result''
touchManagedPtr conn
return maybeResult
#if ENABLE_OVERLOADING
data DtlsConnectionGetNegotiatedProtocolMethodInfo
instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetNegotiatedProtocolMethodInfo a signature where
overloadedMethod _ = dtlsConnectionGetNegotiatedProtocol
#endif
-- method DtlsConnection::get_peer_certificate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificate"}))
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_get_peer_certificate" g_dtls_connection_get_peer_certificate ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
IO (Ptr Gio.TlsCertificate.TlsCertificate)
{- |
Gets /@conn@/\'s peer\'s certificate after the handshake has completed.
(It is not set during the emission of
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@.)
/Since: 2.48/
-}
dtlsConnectionGetPeerCertificate ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> m Gio.TlsCertificate.TlsCertificate
{- ^ __Returns:__ /@conn@/\'s peer\'s certificate, or 'Nothing' -}
dtlsConnectionGetPeerCertificate conn = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result <- g_dtls_connection_get_peer_certificate conn'
checkUnexpectedReturnNULL "dtlsConnectionGetPeerCertificate" result
result' <- (newObject Gio.TlsCertificate.TlsCertificate) result
touchManagedPtr conn
return result'
#if ENABLE_OVERLOADING
data DtlsConnectionGetPeerCertificateMethodInfo
instance (signature ~ (m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetPeerCertificateMethodInfo a signature where
overloadedMethod _ = dtlsConnectionGetPeerCertificate
#endif
-- method DtlsConnection::get_peer_certificate_errors
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}))
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_get_peer_certificate_errors" g_dtls_connection_get_peer_certificate_errors ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
IO CUInt
{- |
Gets the errors associated with validating /@conn@/\'s peer\'s
certificate, after the handshake has completed. (It is not set
during the emission of 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@.)
/Since: 2.48/
-}
dtlsConnectionGetPeerCertificateErrors ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> m [Gio.Flags.TlsCertificateFlags]
{- ^ __Returns:__ /@conn@/\'s peer\'s certificate errors -}
dtlsConnectionGetPeerCertificateErrors conn = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result <- g_dtls_connection_get_peer_certificate_errors conn'
let result' = wordToGFlags result
touchManagedPtr conn
return result'
#if ENABLE_OVERLOADING
data DtlsConnectionGetPeerCertificateErrorsMethodInfo
instance (signature ~ (m [Gio.Flags.TlsCertificateFlags]), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetPeerCertificateErrorsMethodInfo a signature where
overloadedMethod _ = dtlsConnectionGetPeerCertificateErrors
#endif
-- method DtlsConnection::get_rehandshake_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsRehandshakeMode"}))
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_get_rehandshake_mode" g_dtls_connection_get_rehandshake_mode ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
IO CUInt
{- |
Gets /@conn@/ rehandshaking mode. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRehandshakeMode' for details.
/Since: 2.48/
-}
dtlsConnectionGetRehandshakeMode ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> m Gio.Enums.TlsRehandshakeMode
{- ^ __Returns:__ /@conn@/\'s rehandshaking mode -}
dtlsConnectionGetRehandshakeMode conn = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result <- g_dtls_connection_get_rehandshake_mode conn'
let result' = (toEnum . fromIntegral) result
touchManagedPtr conn
return result'
#if ENABLE_OVERLOADING
data DtlsConnectionGetRehandshakeModeMethodInfo
instance (signature ~ (m Gio.Enums.TlsRehandshakeMode), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetRehandshakeModeMethodInfo a signature where
overloadedMethod _ = dtlsConnectionGetRehandshakeMode
#endif
-- method DtlsConnection::get_require_close_notify
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_get_require_close_notify" g_dtls_connection_get_require_close_notify ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
IO CInt
{- |
Tests whether or not /@conn@/ expects a proper TLS close notification
when the connection is closed. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRequireCloseNotify' for details.
/Since: 2.48/
-}
dtlsConnectionGetRequireCloseNotify ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> m Bool
{- ^ __Returns:__ 'True' if /@conn@/ requires a proper TLS close notification. -}
dtlsConnectionGetRequireCloseNotify conn = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result <- g_dtls_connection_get_require_close_notify conn'
let result' = (/= 0) result
touchManagedPtr conn
return result'
#if ENABLE_OVERLOADING
data DtlsConnectionGetRequireCloseNotifyMethodInfo
instance (signature ~ (m Bool), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionGetRequireCloseNotifyMethodInfo a signature where
overloadedMethod _ = dtlsConnectionGetRequireCloseNotify
#endif
-- method DtlsConnection::handshake
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False
foreign import ccall "g_dtls_connection_handshake" g_dtls_connection_handshake ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
Ptr (Ptr GError) -> -- error
IO CInt
{- |
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 (or after sending a \"STARTTLS\"-type command) and may
need to rehandshake later if the server requests it,
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' will handle this for you automatically when you try
to send or receive data on the connection. However, you can call
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionHandshake' manually if you want to know for sure
whether the initial handshake succeeded or failed (as opposed to
just immediately trying to write to /@conn@/, in which
case if it fails, it may not be possible to tell if it failed
before or after completing the handshake).
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.
If TLS 1.2 or older is in use, you may call
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionHandshake' after the initial handshake to
rehandshake; however, this usage is deprecated because rehandshaking
is no longer part of the TLS protocol in TLS 1.3. Accordingly, the
behavior of calling this function after the initial handshake is now
undefined, except it is guaranteed to be reasonable and
nondestructive so as to preserve compatibility with code written for
older versions of GLib.
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept_certificate/@ may be emitted during the
handshake.
/Since: 2.48/
-}
dtlsConnectionHandshake ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Maybe (b)
{- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
-> m ()
{- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dtlsConnectionHandshake conn cancellable = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
onException (do
_ <- propagateGError $ g_dtls_connection_handshake conn' maybeCancellable
touchManagedPtr conn
whenJust cancellable touchManagedPtr
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data DtlsConnectionHandshakeMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionHandshakeMethodInfo a signature where
overloadedMethod _ = dtlsConnectionHandshake
#endif
-- method DtlsConnection::handshake_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the handshake is complete", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 4, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_handshake_async" g_dtls_connection_handshake_async ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Int32 -> -- io_priority : TBasicType TInt
Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
Ptr () -> -- user_data : TBasicType TPtr
IO ()
{- |
Asynchronously performs a TLS handshake on /@conn@/. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionHandshake' for more information.
/Since: 2.48/
-}
dtlsConnectionHandshakeAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Int32
{- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
-> Maybe (b)
{- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
{- ^ /@callback@/: callback to call when the handshake is complete -}
-> m ()
dtlsConnectionHandshakeAsync conn ioPriority cancellable callback = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
maybeCallback <- case callback of
Nothing -> return (castPtrToFunPtr nullPtr)
Just jCallback -> do
ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
poke ptrcallback jCallback'
return jCallback'
let userData = nullPtr
g_dtls_connection_handshake_async conn' ioPriority maybeCancellable maybeCallback userData
touchManagedPtr conn
whenJust cancellable touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionHandshakeAsyncMethodInfo
instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionHandshakeAsyncMethodInfo a signature where
overloadedMethod _ = dtlsConnectionHandshakeAsync
#endif
-- method DtlsConnection::handshake_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult.", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False
foreign import ccall "g_dtls_connection_handshake_finish" g_dtls_connection_handshake_finish ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
Ptr (Ptr GError) -> -- error
IO CInt
{- |
Finish an asynchronous TLS handshake operation. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionHandshake' for more information.
/Since: 2.48/
-}
dtlsConnectionHandshakeFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> b
{- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -}
-> m ()
{- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dtlsConnectionHandshakeFinish conn result_ = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result_' <- unsafeManagedPtrCastPtr result_
onException (do
_ <- propagateGError $ g_dtls_connection_handshake_finish conn' result_'
touchManagedPtr conn
touchManagedPtr result_
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data DtlsConnectionHandshakeFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DtlsConnectionHandshakeFinishMethodInfo a signature where
overloadedMethod _ = dtlsConnectionHandshakeFinish
#endif
-- method DtlsConnection::set_advertised_protocols
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "protocols", argType = TCArray True (-1) (-1) (TBasicType TUTF8), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a %NULL-terminated\n array of ALPN protocol names (eg, \"http/1.1\", \"h2\"), or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_set_advertised_protocols" g_dtls_connection_set_advertised_protocols ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr CString -> -- protocols : TCArray True (-1) (-1) (TBasicType TUTF8)
IO ()
{- |
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
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionGetNegotiatedProtocol' to find the negotiated
protocol after the handshake. Specifying 'Nothing' for the the value
of /@protocols@/ will disable ALPN negotiation.
See <https://www.iana.org/assignments/tls-extensiontype-values/tls-extensiontype-values.xhtml#alpn-protocol-ids IANA TLS ALPN Protocol IDs>
for a list of registered protocol IDs.
/Since: 2.60/
-}
dtlsConnectionSetAdvertisedProtocols ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Maybe ([T.Text])
{- ^ /@protocols@/: a 'Nothing'-terminated
array of ALPN protocol names (eg, \"http\/1.1\", \"h2\"), or 'Nothing' -}
-> m ()
dtlsConnectionSetAdvertisedProtocols conn protocols = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
maybeProtocols <- case protocols of
Nothing -> return nullPtr
Just jProtocols -> do
jProtocols' <- packZeroTerminatedUTF8CArray jProtocols
return jProtocols'
g_dtls_connection_set_advertised_protocols conn' maybeProtocols
touchManagedPtr conn
mapZeroTerminatedCArray freeMem maybeProtocols
freeMem maybeProtocols
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionSetAdvertisedProtocolsMethodInfo
instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionSetAdvertisedProtocolsMethodInfo a signature where
overloadedMethod _ = dtlsConnectionSetAdvertisedProtocols
#endif
-- method DtlsConnection::set_certificate
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "certificate", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificate"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the certificate to use for @conn", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_set_certificate" g_dtls_connection_set_certificate ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.TlsCertificate.TlsCertificate -> -- certificate : TInterface (Name {namespace = "Gio", name = "TlsCertificate"})
IO ()
{- |
This sets the certificate that /@conn@/ will present to its peer
during the TLS handshake. For a 'GI.Gio.Interfaces.DtlsServerConnection.DtlsServerConnection', it is
mandatory to set this, and that will normally be done at construct
time.
For a 'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection', this is optional. If a handshake fails
with 'GI.Gio.Enums.TlsErrorCertificateRequired', that means that the server
requires a certificate, and if you try connecting again, you should
call this method first. You can call
'GI.Gio.Interfaces.DtlsClientConnection.dtlsClientConnectionGetAcceptedCas' 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 'GI.Gio.Interfaces.DtlsClientConnection.dtlsClientConnectionGetAcceptedCas' will return
non-'Nothing'.)
/Since: 2.48/
-}
dtlsConnectionSetCertificate ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> b
{- ^ /@certificate@/: the certificate to use for /@conn@/ -}
-> m ()
dtlsConnectionSetCertificate conn certificate = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
certificate' <- unsafeManagedPtrCastPtr certificate
g_dtls_connection_set_certificate conn' certificate'
touchManagedPtr conn
touchManagedPtr certificate
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionSetCertificateMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo DtlsConnectionSetCertificateMethodInfo a signature where
overloadedMethod _ = dtlsConnectionSetCertificate
#endif
-- method DtlsConnection::set_database
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "database", argType = TInterface (Name {namespace = "Gio", name = "TlsDatabase"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsDatabase", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_set_database" g_dtls_connection_set_database ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.TlsDatabase.TlsDatabase -> -- database : TInterface (Name {namespace = "Gio", name = "TlsDatabase"})
IO ()
{- |
Sets the certificate database that is used to verify peer certificates.
This is set to the default database by default. See
'GI.Gio.Interfaces.TlsBackend.tlsBackendGetDefaultDatabase'. If set to 'Nothing', then
peer certificate validation will always set the
'GI.Gio.Flags.TlsCertificateFlagsUnknownCa' error (meaning
'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'::@/accept-certificate/@ will always be emitted on
client-side connections, unless that bit is not set in
'GI.Gio.Interfaces.DtlsClientConnection.DtlsClientConnection':@/validation-flags/@).
/Since: 2.48/
-}
dtlsConnectionSetDatabase ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.TlsDatabase.IsTlsDatabase b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> b
{- ^ /@database@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -}
-> m ()
dtlsConnectionSetDatabase conn database = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
database' <- unsafeManagedPtrCastPtr database
g_dtls_connection_set_database conn' database'
touchManagedPtr conn
touchManagedPtr database
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionSetDatabaseMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.TlsDatabase.IsTlsDatabase b) => O.MethodInfo DtlsConnectionSetDatabaseMethodInfo a signature where
overloadedMethod _ = dtlsConnectionSetDatabase
#endif
-- method DtlsConnection::set_interaction
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a connection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "interaction", argType = TInterface (Name {namespace = "Gio", name = "TlsInteraction"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "an interaction object, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_set_interaction" g_dtls_connection_set_interaction ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.TlsInteraction.TlsInteraction -> -- interaction : TInterface (Name {namespace = "Gio", name = "TlsInteraction"})
IO ()
{- |
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
'GI.Gio.Objects.TlsInteraction.TlsInteraction'. 'Nothing' can also be provided if no user interaction
should occur for this connection.
/Since: 2.48/
-}
dtlsConnectionSetInteraction ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.TlsInteraction.IsTlsInteraction b) =>
a
{- ^ /@conn@/: a connection -}
-> Maybe (b)
{- ^ /@interaction@/: an interaction object, or 'Nothing' -}
-> m ()
dtlsConnectionSetInteraction conn interaction = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
maybeInteraction <- case interaction of
Nothing -> return nullPtr
Just jInteraction -> do
jInteraction' <- unsafeManagedPtrCastPtr jInteraction
return jInteraction'
g_dtls_connection_set_interaction conn' maybeInteraction
touchManagedPtr conn
whenJust interaction touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionSetInteractionMethodInfo
instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsDtlsConnection a, Gio.TlsInteraction.IsTlsInteraction b) => O.MethodInfo DtlsConnectionSetInteractionMethodInfo a signature where
overloadedMethod _ = dtlsConnectionSetInteraction
#endif
-- method DtlsConnection::set_rehandshake_mode
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "mode", argType = TInterface (Name {namespace = "Gio", name = "TlsRehandshakeMode"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the rehandshaking mode", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_set_rehandshake_mode" g_dtls_connection_set_rehandshake_mode ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
CUInt -> -- mode : TInterface (Name {namespace = "Gio", name = "TlsRehandshakeMode"})
IO ()
{-# DEPRECATED dtlsConnectionSetRehandshakeMode ["(Since version 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."] #-}
{- |
Sets how /@conn@/ behaves with respect to rehandshaking requests.
'GI.Gio.Enums.TlsRehandshakeModeNever' means that it will never agree to
rehandshake after the initial handshake is complete. (For a client,
this means it will refuse rehandshake requests from the server, and
for a server, this means it will close the connection with an error
if the client attempts to rehandshake.)
'GI.Gio.Enums.TlsRehandshakeModeSafely' means that the connection will allow a
rehandshake only if the other end of the connection supports the
TLS @renegotiation_info@ extension. This is the default behavior,
but means that rehandshaking will not work against older
implementations that do not support that extension.
'GI.Gio.Enums.TlsRehandshakeModeUnsafely' means that the connection will allow
rehandshaking even without the @renegotiation_info@ extension. On
the server side in particular, this is not recommended, since it
leaves the server open to certain attacks. However, this mode is
necessary if you need to allow renegotiation with older client
software.
/Since: 2.48/
-}
dtlsConnectionSetRehandshakeMode ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Gio.Enums.TlsRehandshakeMode
{- ^ /@mode@/: the rehandshaking mode -}
-> m ()
dtlsConnectionSetRehandshakeMode conn mode = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
let mode' = (fromIntegral . fromEnum) mode
g_dtls_connection_set_rehandshake_mode conn' mode'
touchManagedPtr conn
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionSetRehandshakeModeMethodInfo
instance (signature ~ (Gio.Enums.TlsRehandshakeMode -> m ()), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionSetRehandshakeModeMethodInfo a signature where
overloadedMethod _ = dtlsConnectionSetRehandshakeMode
#endif
-- method DtlsConnection::set_require_close_notify
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "require_close_notify", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether or not to require close notification", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_set_require_close_notify" g_dtls_connection_set_require_close_notify ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
CInt -> -- require_close_notify : TBasicType TBoolean
IO ()
{- |
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
'GI.Gio.Enums.TlsErrorEof' 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 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionSetRequireCloseNotify' 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
'GI.Gio.Interfaces.DatagramBased.DatagramBased', 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 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionCloseAsync' 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 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection':@/base-socket/@ rather
than closing /@conn@/ itself.
/Since: 2.48/
-}
dtlsConnectionSetRequireCloseNotify ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Bool
{- ^ /@requireCloseNotify@/: whether or not to require close notification -}
-> m ()
dtlsConnectionSetRequireCloseNotify conn requireCloseNotify = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
let requireCloseNotify' = (fromIntegral . fromEnum) requireCloseNotify
g_dtls_connection_set_require_close_notify conn' requireCloseNotify'
touchManagedPtr conn
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionSetRequireCloseNotifyMethodInfo
instance (signature ~ (Bool -> m ()), MonadIO m, IsDtlsConnection a) => O.MethodInfo DtlsConnectionSetRequireCloseNotifyMethodInfo a signature where
overloadedMethod _ = dtlsConnectionSetRequireCloseNotify
#endif
-- method DtlsConnection::shutdown
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shutdown_read", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to stop reception of incoming datagrams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shutdown_write", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to stop sending outgoing datagrams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False
foreign import ccall "g_dtls_connection_shutdown" g_dtls_connection_shutdown ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
CInt -> -- shutdown_read : TBasicType TBoolean
CInt -> -- shutdown_write : TBasicType TBoolean
Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
Ptr (Ptr GError) -> -- error
IO CInt
{- |
Shut down part or all of a DTLS connection.
If /@shutdownRead@/ is 'True' then the receiving side of the connection is shut
down, and further reading is disallowed. Subsequent calls to
'GI.Gio.Interfaces.DatagramBased.datagramBasedReceiveMessages' will return 'GI.Gio.Enums.IOErrorEnumClosed'.
If /@shutdownWrite@/ is 'True' then the sending side of the connection is shut
down, and further writing is disallowed. Subsequent calls to
'GI.Gio.Interfaces.DatagramBased.datagramBasedSendMessages' will return 'GI.Gio.Enums.IOErrorEnumClosed'.
It is allowed for both /@shutdownRead@/ and /@shutdownWrite@/ to be TRUE — this
is equivalent to calling 'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionClose'.
If /@cancellable@/ is cancelled, the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' may be left
partially-closed and any pending untransmitted data may be lost. Call
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionShutdown' again to complete closing the 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'.
/Since: 2.48/
-}
dtlsConnectionShutdown ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Bool
{- ^ /@shutdownRead@/: 'True' to stop reception of incoming datagrams -}
-> Bool
{- ^ /@shutdownWrite@/: 'True' to stop sending outgoing datagrams -}
-> Maybe (b)
{- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
-> m ()
{- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dtlsConnectionShutdown conn shutdownRead shutdownWrite cancellable = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
let shutdownRead' = (fromIntegral . fromEnum) shutdownRead
let shutdownWrite' = (fromIntegral . fromEnum) shutdownWrite
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
onException (do
_ <- propagateGError $ g_dtls_connection_shutdown conn' shutdownRead' shutdownWrite' maybeCancellable
touchManagedPtr conn
whenJust cancellable touchManagedPtr
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data DtlsConnectionShutdownMethodInfo
instance (signature ~ (Bool -> Bool -> Maybe (b) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionShutdownMethodInfo a signature where
overloadedMethod _ = dtlsConnectionShutdown
#endif
-- method DtlsConnection::shutdown_async
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shutdown_read", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to stop reception of incoming datagrams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "shutdown_write", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "%TRUE to stop sending outgoing datagrams", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "io_priority", argType = TBasicType TInt, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the [I/O priority][io-priority] of the request", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "cancellable", argType = TInterface (Name {namespace = "Gio", name = "Cancellable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "a #GCancellable, or %NULL", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "callback", argType = TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "callback to call when the shutdown operation is complete", sinceVersion = Nothing}, argScope = ScopeTypeAsync, argClosure = 6, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "user_data", argType = TBasicType TPtr, direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the data to pass to the callback function", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Nothing
-- throws : False
-- Skip return : False
foreign import ccall "g_dtls_connection_shutdown_async" g_dtls_connection_shutdown_async ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
CInt -> -- shutdown_read : TBasicType TBoolean
CInt -> -- shutdown_write : TBasicType TBoolean
Int32 -> -- io_priority : TBasicType TInt
Ptr Gio.Cancellable.Cancellable -> -- cancellable : TInterface (Name {namespace = "Gio", name = "Cancellable"})
FunPtr Gio.Callbacks.C_AsyncReadyCallback -> -- callback : TInterface (Name {namespace = "Gio", name = "AsyncReadyCallback"})
Ptr () -> -- user_data : TBasicType TPtr
IO ()
{- |
Asynchronously shut down part or all of the DTLS connection. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionShutdown' for more information.
/Since: 2.48/
-}
dtlsConnectionShutdownAsync ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> Bool
{- ^ /@shutdownRead@/: 'True' to stop reception of incoming datagrams -}
-> Bool
{- ^ /@shutdownWrite@/: 'True' to stop sending outgoing datagrams -}
-> Int32
{- ^ /@ioPriority@/: the [I\/O priority][io-priority] of the request -}
-> Maybe (b)
{- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -}
-> Maybe (Gio.Callbacks.AsyncReadyCallback)
{- ^ /@callback@/: callback to call when the shutdown operation is complete -}
-> m ()
dtlsConnectionShutdownAsync conn shutdownRead shutdownWrite ioPriority cancellable callback = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
let shutdownRead' = (fromIntegral . fromEnum) shutdownRead
let shutdownWrite' = (fromIntegral . fromEnum) shutdownWrite
maybeCancellable <- case cancellable of
Nothing -> return nullPtr
Just jCancellable -> do
jCancellable' <- unsafeManagedPtrCastPtr jCancellable
return jCancellable'
maybeCallback <- case callback of
Nothing -> return (castPtrToFunPtr nullPtr)
Just jCallback -> do
ptrcallback <- callocMem :: IO (Ptr (FunPtr Gio.Callbacks.C_AsyncReadyCallback))
jCallback' <- Gio.Callbacks.mk_AsyncReadyCallback (Gio.Callbacks.wrap_AsyncReadyCallback (Just ptrcallback) (Gio.Callbacks.drop_closures_AsyncReadyCallback jCallback))
poke ptrcallback jCallback'
return jCallback'
let userData = nullPtr
g_dtls_connection_shutdown_async conn' shutdownRead' shutdownWrite' ioPriority maybeCancellable maybeCallback userData
touchManagedPtr conn
whenJust cancellable touchManagedPtr
return ()
#if ENABLE_OVERLOADING
data DtlsConnectionShutdownAsyncMethodInfo
instance (signature ~ (Bool -> Bool -> Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsDtlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo DtlsConnectionShutdownAsyncMethodInfo a signature where
overloadedMethod _ = dtlsConnectionShutdownAsync
#endif
-- method DtlsConnection::shutdown_finish
-- method type : OrdinaryMethod
-- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "DtlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GDtlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "result", argType = TInterface (Name {namespace = "Gio", name = "AsyncResult"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GAsyncResult", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}]
-- Lengths : []
-- returnType : Just (TBasicType TBoolean)
-- throws : True
-- Skip return : False
foreign import ccall "g_dtls_connection_shutdown_finish" g_dtls_connection_shutdown_finish ::
Ptr DtlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "DtlsConnection"})
Ptr Gio.AsyncResult.AsyncResult -> -- result : TInterface (Name {namespace = "Gio", name = "AsyncResult"})
Ptr (Ptr GError) -> -- error
IO CInt
{- |
Finish an asynchronous TLS shutdown operation. See
'GI.Gio.Interfaces.DtlsConnection.dtlsConnectionShutdown' for more information.
/Since: 2.48/
-}
dtlsConnectionShutdownFinish ::
(B.CallStack.HasCallStack, MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) =>
a
{- ^ /@conn@/: a 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection' -}
-> b
{- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult' -}
-> m ()
{- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -}
dtlsConnectionShutdownFinish conn result_ = liftIO $ do
conn' <- unsafeManagedPtrCastPtr conn
result_' <- unsafeManagedPtrCastPtr result_
onException (do
_ <- propagateGError $ g_dtls_connection_shutdown_finish conn' result_'
touchManagedPtr conn
touchManagedPtr result_
return ()
) (do
return ()
)
#if ENABLE_OVERLOADING
data DtlsConnectionShutdownFinishMethodInfo
instance (signature ~ (b -> m ()), MonadIO m, IsDtlsConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo DtlsConnectionShutdownFinishMethodInfo a signature where
overloadedMethod _ = dtlsConnectionShutdownFinish
#endif