{- | 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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 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