{- | 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.Objects.TlsConnection.TlsConnection' is the base TLS connection class type, which wraps a 'GI.Gio.Objects.IOStream.IOStream' and provides TLS encryption on top of it. Its subclasses, 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' and 'GI.Gio.Interfaces.TlsServerConnection.TlsServerConnection', implement client-side and server-side TLS, respectively. For DTLS (Datagram TLS) support, see 'GI.Gio.Interfaces.DtlsConnection.DtlsConnection'. /Since: 2.28/ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Objects.TlsConnection ( -- * Exported types TlsConnection(..) , IsTlsConnection , toTlsConnection , noTlsConnection , -- * Methods -- ** emitAcceptCertificate #method:emitAcceptCertificate# #if ENABLE_OVERLOADING TlsConnectionEmitAcceptCertificateMethodInfo, #endif tlsConnectionEmitAcceptCertificate , -- ** getCertificate #method:getCertificate# #if ENABLE_OVERLOADING TlsConnectionGetCertificateMethodInfo , #endif tlsConnectionGetCertificate , -- ** getDatabase #method:getDatabase# #if ENABLE_OVERLOADING TlsConnectionGetDatabaseMethodInfo , #endif tlsConnectionGetDatabase , -- ** getInteraction #method:getInteraction# #if ENABLE_OVERLOADING TlsConnectionGetInteractionMethodInfo , #endif tlsConnectionGetInteraction , -- ** getNegotiatedProtocol #method:getNegotiatedProtocol# #if ENABLE_OVERLOADING TlsConnectionGetNegotiatedProtocolMethodInfo, #endif tlsConnectionGetNegotiatedProtocol , -- ** getPeerCertificate #method:getPeerCertificate# #if ENABLE_OVERLOADING TlsConnectionGetPeerCertificateMethodInfo, #endif tlsConnectionGetPeerCertificate , -- ** getPeerCertificateErrors #method:getPeerCertificateErrors# #if ENABLE_OVERLOADING TlsConnectionGetPeerCertificateErrorsMethodInfo, #endif tlsConnectionGetPeerCertificateErrors , -- ** getRehandshakeMode #method:getRehandshakeMode# #if ENABLE_OVERLOADING TlsConnectionGetRehandshakeModeMethodInfo, #endif tlsConnectionGetRehandshakeMode , -- ** getRequireCloseNotify #method:getRequireCloseNotify# #if ENABLE_OVERLOADING TlsConnectionGetRequireCloseNotifyMethodInfo, #endif tlsConnectionGetRequireCloseNotify , -- ** getUseSystemCertdb #method:getUseSystemCertdb# #if ENABLE_OVERLOADING TlsConnectionGetUseSystemCertdbMethodInfo, #endif tlsConnectionGetUseSystemCertdb , -- ** handshake #method:handshake# #if ENABLE_OVERLOADING TlsConnectionHandshakeMethodInfo , #endif tlsConnectionHandshake , -- ** handshakeAsync #method:handshakeAsync# #if ENABLE_OVERLOADING TlsConnectionHandshakeAsyncMethodInfo , #endif tlsConnectionHandshakeAsync , -- ** handshakeFinish #method:handshakeFinish# #if ENABLE_OVERLOADING TlsConnectionHandshakeFinishMethodInfo , #endif tlsConnectionHandshakeFinish , -- ** setAdvertisedProtocols #method:setAdvertisedProtocols# #if ENABLE_OVERLOADING TlsConnectionSetAdvertisedProtocolsMethodInfo, #endif tlsConnectionSetAdvertisedProtocols , -- ** setCertificate #method:setCertificate# #if ENABLE_OVERLOADING TlsConnectionSetCertificateMethodInfo , #endif tlsConnectionSetCertificate , -- ** setDatabase #method:setDatabase# #if ENABLE_OVERLOADING TlsConnectionSetDatabaseMethodInfo , #endif tlsConnectionSetDatabase , -- ** setInteraction #method:setInteraction# #if ENABLE_OVERLOADING TlsConnectionSetInteractionMethodInfo , #endif tlsConnectionSetInteraction , -- ** setRehandshakeMode #method:setRehandshakeMode# #if ENABLE_OVERLOADING TlsConnectionSetRehandshakeModeMethodInfo, #endif tlsConnectionSetRehandshakeMode , -- ** setRequireCloseNotify #method:setRequireCloseNotify# #if ENABLE_OVERLOADING TlsConnectionSetRequireCloseNotifyMethodInfo, #endif tlsConnectionSetRequireCloseNotify , -- ** setUseSystemCertdb #method:setUseSystemCertdb# #if ENABLE_OVERLOADING TlsConnectionSetUseSystemCertdbMethodInfo, #endif tlsConnectionSetUseSystemCertdb , -- * Properties -- ** advertisedProtocols #attr:advertisedProtocols# {- | The list of application-layer protocols that the connection advertises that it is willing to speak. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetAdvertisedProtocols'. /Since: 2.60/ -} #if ENABLE_OVERLOADING TlsConnectionAdvertisedProtocolsPropertyInfo, #endif clearTlsConnectionAdvertisedProtocols , constructTlsConnectionAdvertisedProtocols, getTlsConnectionAdvertisedProtocols , setTlsConnectionAdvertisedProtocols , #if ENABLE_OVERLOADING tlsConnectionAdvertisedProtocols , #endif -- ** baseIoStream #attr:baseIoStream# {- | The 'GI.Gio.Objects.IOStream.IOStream' that the connection wraps. The connection holds a reference to this stream, and may run operations on the stream from other threads throughout its lifetime. Consequently, after the 'GI.Gio.Objects.IOStream.IOStream' has been constructed, application code may only run its own operations on this stream when no 'GI.Gio.Objects.IOStream.IOStream' operations are running. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsConnectionBaseIoStreamPropertyInfo , #endif constructTlsConnectionBaseIoStream , getTlsConnectionBaseIoStream , #if ENABLE_OVERLOADING tlsConnectionBaseIoStream , #endif -- ** certificate #attr:certificate# {- | The connection\'s certificate; see 'GI.Gio.Objects.TlsConnection.tlsConnectionSetCertificate'. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsConnectionCertificatePropertyInfo , #endif constructTlsConnectionCertificate , getTlsConnectionCertificate , setTlsConnectionCertificate , #if ENABLE_OVERLOADING tlsConnectionCertificate , #endif -- ** 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.30/ -} #if ENABLE_OVERLOADING TlsConnectionDatabasePropertyInfo , #endif constructTlsConnectionDatabase , getTlsConnectionDatabase , setTlsConnectionDatabase , #if ENABLE_OVERLOADING tlsConnectionDatabase , #endif -- ** 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.30/ -} #if ENABLE_OVERLOADING TlsConnectionInteractionPropertyInfo , #endif clearTlsConnectionInteraction , constructTlsConnectionInteraction , getTlsConnectionInteraction , setTlsConnectionInteraction , #if ENABLE_OVERLOADING tlsConnectionInteraction , #endif -- ** negotiatedProtocol #attr:negotiatedProtocol# {- | The application-layer protocol negotiated during the TLS handshake. See 'GI.Gio.Objects.TlsConnection.tlsConnectionGetNegotiatedProtocol'. /Since: 2.60/ -} #if ENABLE_OVERLOADING TlsConnectionNegotiatedProtocolPropertyInfo, #endif getTlsConnectionNegotiatedProtocol , #if ENABLE_OVERLOADING tlsConnectionNegotiatedProtocol , #endif -- ** 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.Objects.TlsConnection.TlsConnection'::@/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.28/ -} #if ENABLE_OVERLOADING TlsConnectionPeerCertificatePropertyInfo, #endif getTlsConnectionPeerCertificate , #if ENABLE_OVERLOADING tlsConnectionPeerCertificate , #endif -- ** peerCertificateErrors #attr:peerCertificateErrors# {- | The errors noticed-and-ignored while verifying 'GI.Gio.Objects.TlsConnection.TlsConnection':@/peer-certificate/@. Normally this should be 0, but it may not be if 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection':@/validation-flags/@ is not 'GI.Gio.Flags.TlsCertificateFlagsValidateAll', or if 'GI.Gio.Objects.TlsConnection.TlsConnection'::@/accept-certificate/@ overrode the default behavior. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsConnectionPeerCertificateErrorsPropertyInfo, #endif getTlsConnectionPeerCertificateErrors , #if ENABLE_OVERLOADING tlsConnectionPeerCertificateErrors , #endif -- ** rehandshakeMode #attr:rehandshakeMode# {- | The rehandshaking mode. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetRehandshakeMode'. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsConnectionRehandshakeModePropertyInfo, #endif constructTlsConnectionRehandshakeMode , getTlsConnectionRehandshakeMode , setTlsConnectionRehandshakeMode , #if ENABLE_OVERLOADING tlsConnectionRehandshakeMode , #endif -- ** requireCloseNotify #attr:requireCloseNotify# {- | Whether or not proper TLS close notification is required. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetRequireCloseNotify'. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsConnectionRequireCloseNotifyPropertyInfo, #endif constructTlsConnectionRequireCloseNotify, getTlsConnectionRequireCloseNotify , setTlsConnectionRequireCloseNotify , #if ENABLE_OVERLOADING tlsConnectionRequireCloseNotify , #endif -- ** useSystemCertdb #attr:useSystemCertdb# {- | Whether or not the system certificate database will be used to verify peer certificates. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetUseSystemCertdb'. -} #if ENABLE_OVERLOADING TlsConnectionUseSystemCertdbPropertyInfo, #endif constructTlsConnectionUseSystemCertdb , getTlsConnectionUseSystemCertdb , setTlsConnectionUseSystemCertdb , #if ENABLE_OVERLOADING tlsConnectionUseSystemCertdb , #endif -- * Signals -- ** acceptCertificate #signal:acceptCertificate# C_TlsConnectionAcceptCertificateCallback, TlsConnectionAcceptCertificateCallback , #if ENABLE_OVERLOADING TlsConnectionAcceptCertificateSignalInfo, #endif afterTlsConnectionAcceptCertificate , genClosure_TlsConnectionAcceptCertificate, mk_TlsConnectionAcceptCertificateCallback, noTlsConnectionAcceptCertificateCallback, onTlsConnectionAcceptCertificate , wrap_TlsConnectionAcceptCertificateCallback, ) 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.Objects.Cancellable as Gio.Cancellable import {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream 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 -- | Memory-managed wrapper type. newtype TlsConnection = TlsConnection (ManagedPtr TlsConnection) foreign import ccall "g_tls_connection_get_type" c_g_tls_connection_get_type :: IO GType instance GObject TlsConnection where gobjectType = c_g_tls_connection_get_type -- | Type class for types which can be safely cast to `TlsConnection`, for instance with `toTlsConnection`. class (GObject o, O.IsDescendantOf TlsConnection o) => IsTlsConnection o instance (GObject o, O.IsDescendantOf TlsConnection o) => IsTlsConnection o instance O.HasParentTypes TlsConnection type instance O.ParentTypes TlsConnection = '[Gio.IOStream.IOStream, GObject.Object.Object] -- | Cast to `TlsConnection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toTlsConnection :: (MonadIO m, IsTlsConnection o) => o -> m TlsConnection toTlsConnection = liftIO . unsafeCastTo TlsConnection -- | A convenience alias for `Nothing` :: `Maybe` `TlsConnection`. noTlsConnection :: Maybe TlsConnection noTlsConnection = Nothing #if ENABLE_OVERLOADING type family ResolveTlsConnectionMethod (t :: Symbol) (o :: *) :: * where ResolveTlsConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveTlsConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveTlsConnectionMethod "clearPending" o = Gio.IOStream.IOStreamClearPendingMethodInfo ResolveTlsConnectionMethod "close" o = Gio.IOStream.IOStreamCloseMethodInfo ResolveTlsConnectionMethod "closeAsync" o = Gio.IOStream.IOStreamCloseAsyncMethodInfo ResolveTlsConnectionMethod "closeFinish" o = Gio.IOStream.IOStreamCloseFinishMethodInfo ResolveTlsConnectionMethod "emitAcceptCertificate" o = TlsConnectionEmitAcceptCertificateMethodInfo ResolveTlsConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveTlsConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveTlsConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveTlsConnectionMethod "handshake" o = TlsConnectionHandshakeMethodInfo ResolveTlsConnectionMethod "handshakeAsync" o = TlsConnectionHandshakeAsyncMethodInfo ResolveTlsConnectionMethod "handshakeFinish" o = TlsConnectionHandshakeFinishMethodInfo ResolveTlsConnectionMethod "hasPending" o = Gio.IOStream.IOStreamHasPendingMethodInfo ResolveTlsConnectionMethod "isClosed" o = Gio.IOStream.IOStreamIsClosedMethodInfo ResolveTlsConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveTlsConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveTlsConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveTlsConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveTlsConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveTlsConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveTlsConnectionMethod "spliceAsync" o = Gio.IOStream.IOStreamSpliceAsyncMethodInfo ResolveTlsConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveTlsConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveTlsConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveTlsConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveTlsConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveTlsConnectionMethod "getCertificate" o = TlsConnectionGetCertificateMethodInfo ResolveTlsConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveTlsConnectionMethod "getDatabase" o = TlsConnectionGetDatabaseMethodInfo ResolveTlsConnectionMethod "getInputStream" o = Gio.IOStream.IOStreamGetInputStreamMethodInfo ResolveTlsConnectionMethod "getInteraction" o = TlsConnectionGetInteractionMethodInfo ResolveTlsConnectionMethod "getNegotiatedProtocol" o = TlsConnectionGetNegotiatedProtocolMethodInfo ResolveTlsConnectionMethod "getOutputStream" o = Gio.IOStream.IOStreamGetOutputStreamMethodInfo ResolveTlsConnectionMethod "getPeerCertificate" o = TlsConnectionGetPeerCertificateMethodInfo ResolveTlsConnectionMethod "getPeerCertificateErrors" o = TlsConnectionGetPeerCertificateErrorsMethodInfo ResolveTlsConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveTlsConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveTlsConnectionMethod "getRehandshakeMode" o = TlsConnectionGetRehandshakeModeMethodInfo ResolveTlsConnectionMethod "getRequireCloseNotify" o = TlsConnectionGetRequireCloseNotifyMethodInfo ResolveTlsConnectionMethod "getUseSystemCertdb" o = TlsConnectionGetUseSystemCertdbMethodInfo ResolveTlsConnectionMethod "setAdvertisedProtocols" o = TlsConnectionSetAdvertisedProtocolsMethodInfo ResolveTlsConnectionMethod "setCertificate" o = TlsConnectionSetCertificateMethodInfo ResolveTlsConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveTlsConnectionMethod "setDatabase" o = TlsConnectionSetDatabaseMethodInfo ResolveTlsConnectionMethod "setInteraction" o = TlsConnectionSetInteractionMethodInfo ResolveTlsConnectionMethod "setPending" o = Gio.IOStream.IOStreamSetPendingMethodInfo ResolveTlsConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveTlsConnectionMethod "setRehandshakeMode" o = TlsConnectionSetRehandshakeModeMethodInfo ResolveTlsConnectionMethod "setRequireCloseNotify" o = TlsConnectionSetRequireCloseNotifyMethodInfo ResolveTlsConnectionMethod "setUseSystemCertdb" o = TlsConnectionSetUseSystemCertdbMethodInfo ResolveTlsConnectionMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveTlsConnectionMethod t TlsConnection, O.MethodInfo info TlsConnection p) => OL.IsLabel t (TlsConnection -> 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 -- signal TlsConnection::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.TlsClientConnection.TlsClientConnection':@/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.TlsServerConnection.TlsServerConnection':@/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.28/ -} type TlsConnectionAcceptCertificateCallback = 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` `TlsConnectionAcceptCertificateCallback`@. noTlsConnectionAcceptCertificateCallback :: Maybe TlsConnectionAcceptCertificateCallback noTlsConnectionAcceptCertificateCallback = Nothing -- | Type for the callback on the (unwrapped) C side. type C_TlsConnectionAcceptCertificateCallback = Ptr () -> -- object Ptr Gio.TlsCertificate.TlsCertificate -> CUInt -> Ptr () -> -- user_data IO CInt -- | Generate a function pointer callable from C code, from a `C_TlsConnectionAcceptCertificateCallback`. foreign import ccall "wrapper" mk_TlsConnectionAcceptCertificateCallback :: C_TlsConnectionAcceptCertificateCallback -> IO (FunPtr C_TlsConnectionAcceptCertificateCallback) -- | Wrap the callback into a `GClosure`. genClosure_TlsConnectionAcceptCertificate :: MonadIO m => TlsConnectionAcceptCertificateCallback -> m (GClosure C_TlsConnectionAcceptCertificateCallback) genClosure_TlsConnectionAcceptCertificate cb = liftIO $ do let cb' = wrap_TlsConnectionAcceptCertificateCallback cb mk_TlsConnectionAcceptCertificateCallback cb' >>= B.GClosure.newGClosure -- | Wrap a `TlsConnectionAcceptCertificateCallback` into a `C_TlsConnectionAcceptCertificateCallback`. wrap_TlsConnectionAcceptCertificateCallback :: TlsConnectionAcceptCertificateCallback -> C_TlsConnectionAcceptCertificateCallback wrap_TlsConnectionAcceptCertificateCallback _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' tlsConnection #acceptCertificate callback @ -} onTlsConnectionAcceptCertificate :: (IsTlsConnection a, MonadIO m) => a -> TlsConnectionAcceptCertificateCallback -> m SignalHandlerId onTlsConnectionAcceptCertificate obj cb = liftIO $ do let cb' = wrap_TlsConnectionAcceptCertificateCallback cb cb'' <- mk_TlsConnectionAcceptCertificateCallback 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' tlsConnection #acceptCertificate callback @ -} afterTlsConnectionAcceptCertificate :: (IsTlsConnection a, MonadIO m) => a -> TlsConnectionAcceptCertificateCallback -> m SignalHandlerId afterTlsConnectionAcceptCertificate obj cb = liftIO $ do let cb' = wrap_TlsConnectionAcceptCertificateCallback cb cb'' <- mk_TlsConnectionAcceptCertificateCallback cb' connectSignalFunPtr obj "accept-certificate" cb'' SignalConnectAfter -- 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' tlsConnection #advertisedProtocols @ -} getTlsConnectionAdvertisedProtocols :: (MonadIO m, IsTlsConnection o) => o -> m (Maybe [T.Text]) getTlsConnectionAdvertisedProtocols 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' tlsConnection [ #advertisedProtocols 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsConnectionAdvertisedProtocols :: (MonadIO m, IsTlsConnection o) => o -> [T.Text] -> m () setTlsConnectionAdvertisedProtocols 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`. -} constructTlsConnectionAdvertisedProtocols :: (IsTlsConnection o) => [T.Text] -> IO (GValueConstruct o) constructTlsConnectionAdvertisedProtocols 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 @ -} clearTlsConnectionAdvertisedProtocols :: (MonadIO m, IsTlsConnection o) => o -> m () clearTlsConnectionAdvertisedProtocols obj = liftIO $ B.Properties.setObjectPropertyStringArray obj "advertised-protocols" (Nothing :: Maybe [T.Text]) #if ENABLE_OVERLOADING data TlsConnectionAdvertisedProtocolsPropertyInfo instance AttrInfo TlsConnectionAdvertisedProtocolsPropertyInfo where type AttrAllowedOps TlsConnectionAdvertisedProtocolsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TlsConnectionAdvertisedProtocolsPropertyInfo = (~) [T.Text] type AttrBaseTypeConstraint TlsConnectionAdvertisedProtocolsPropertyInfo = IsTlsConnection type AttrGetType TlsConnectionAdvertisedProtocolsPropertyInfo = (Maybe [T.Text]) type AttrLabel TlsConnectionAdvertisedProtocolsPropertyInfo = "advertised-protocols" type AttrOrigin TlsConnectionAdvertisedProtocolsPropertyInfo = TlsConnection attrGet _ = getTlsConnectionAdvertisedProtocols attrSet _ = setTlsConnectionAdvertisedProtocols attrConstruct _ = constructTlsConnectionAdvertisedProtocols attrClear _ = clearTlsConnectionAdvertisedProtocols #endif -- VVV Prop "base-io-stream" -- Type: TInterface (Name {namespace = "Gio", name = "IOStream"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstructOnly] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@base-io-stream@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' tlsConnection #baseIoStream @ -} getTlsConnectionBaseIoStream :: (MonadIO m, IsTlsConnection o) => o -> m (Maybe Gio.IOStream.IOStream) getTlsConnectionBaseIoStream obj = liftIO $ B.Properties.getObjectPropertyObject obj "base-io-stream" Gio.IOStream.IOStream {- | Construct a `GValueConstruct` with valid value for the “@base-io-stream@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructTlsConnectionBaseIoStream :: (IsTlsConnection o, Gio.IOStream.IsIOStream a) => a -> IO (GValueConstruct o) constructTlsConnectionBaseIoStream val = B.Properties.constructObjectPropertyObject "base-io-stream" (Just val) #if ENABLE_OVERLOADING data TlsConnectionBaseIoStreamPropertyInfo instance AttrInfo TlsConnectionBaseIoStreamPropertyInfo where type AttrAllowedOps TlsConnectionBaseIoStreamPropertyInfo = '[ 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TlsConnectionBaseIoStreamPropertyInfo = Gio.IOStream.IsIOStream type AttrBaseTypeConstraint TlsConnectionBaseIoStreamPropertyInfo = IsTlsConnection type AttrGetType TlsConnectionBaseIoStreamPropertyInfo = (Maybe Gio.IOStream.IOStream) type AttrLabel TlsConnectionBaseIoStreamPropertyInfo = "base-io-stream" type AttrOrigin TlsConnectionBaseIoStreamPropertyInfo = TlsConnection attrGet _ = getTlsConnectionBaseIoStream attrSet _ = undefined attrConstruct _ = constructTlsConnectionBaseIoStream 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' tlsConnection #certificate @ -} getTlsConnectionCertificate :: (MonadIO m, IsTlsConnection o) => o -> m Gio.TlsCertificate.TlsCertificate getTlsConnectionCertificate obj = liftIO $ checkUnexpectedNothing "getTlsConnectionCertificate" $ 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' tlsConnection [ #certificate 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsConnectionCertificate :: (MonadIO m, IsTlsConnection o, Gio.TlsCertificate.IsTlsCertificate a) => o -> a -> m () setTlsConnectionCertificate 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`. -} constructTlsConnectionCertificate :: (IsTlsConnection o, Gio.TlsCertificate.IsTlsCertificate a) => a -> IO (GValueConstruct o) constructTlsConnectionCertificate val = B.Properties.constructObjectPropertyObject "certificate" (Just val) #if ENABLE_OVERLOADING data TlsConnectionCertificatePropertyInfo instance AttrInfo TlsConnectionCertificatePropertyInfo where type AttrAllowedOps TlsConnectionCertificatePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TlsConnectionCertificatePropertyInfo = Gio.TlsCertificate.IsTlsCertificate type AttrBaseTypeConstraint TlsConnectionCertificatePropertyInfo = IsTlsConnection type AttrGetType TlsConnectionCertificatePropertyInfo = Gio.TlsCertificate.TlsCertificate type AttrLabel TlsConnectionCertificatePropertyInfo = "certificate" type AttrOrigin TlsConnectionCertificatePropertyInfo = TlsConnection attrGet _ = getTlsConnectionCertificate attrSet _ = setTlsConnectionCertificate attrConstruct _ = constructTlsConnectionCertificate 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' tlsConnection #database @ -} getTlsConnectionDatabase :: (MonadIO m, IsTlsConnection o) => o -> m Gio.TlsDatabase.TlsDatabase getTlsConnectionDatabase obj = liftIO $ checkUnexpectedNothing "getTlsConnectionDatabase" $ 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' tlsConnection [ #database 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsConnectionDatabase :: (MonadIO m, IsTlsConnection o, Gio.TlsDatabase.IsTlsDatabase a) => o -> a -> m () setTlsConnectionDatabase 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`. -} constructTlsConnectionDatabase :: (IsTlsConnection o, Gio.TlsDatabase.IsTlsDatabase a) => a -> IO (GValueConstruct o) constructTlsConnectionDatabase val = B.Properties.constructObjectPropertyObject "database" (Just val) #if ENABLE_OVERLOADING data TlsConnectionDatabasePropertyInfo instance AttrInfo TlsConnectionDatabasePropertyInfo where type AttrAllowedOps TlsConnectionDatabasePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TlsConnectionDatabasePropertyInfo = Gio.TlsDatabase.IsTlsDatabase type AttrBaseTypeConstraint TlsConnectionDatabasePropertyInfo = IsTlsConnection type AttrGetType TlsConnectionDatabasePropertyInfo = Gio.TlsDatabase.TlsDatabase type AttrLabel TlsConnectionDatabasePropertyInfo = "database" type AttrOrigin TlsConnectionDatabasePropertyInfo = TlsConnection attrGet _ = getTlsConnectionDatabase attrSet _ = setTlsConnectionDatabase attrConstruct _ = constructTlsConnectionDatabase 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' tlsConnection #interaction @ -} getTlsConnectionInteraction :: (MonadIO m, IsTlsConnection o) => o -> m Gio.TlsInteraction.TlsInteraction getTlsConnectionInteraction obj = liftIO $ checkUnexpectedNothing "getTlsConnectionInteraction" $ 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' tlsConnection [ #interaction 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsConnectionInteraction :: (MonadIO m, IsTlsConnection o, Gio.TlsInteraction.IsTlsInteraction a) => o -> a -> m () setTlsConnectionInteraction 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`. -} constructTlsConnectionInteraction :: (IsTlsConnection o, Gio.TlsInteraction.IsTlsInteraction a) => a -> IO (GValueConstruct o) constructTlsConnectionInteraction 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 @ -} clearTlsConnectionInteraction :: (MonadIO m, IsTlsConnection o) => o -> m () clearTlsConnectionInteraction obj = liftIO $ B.Properties.setObjectPropertyObject obj "interaction" (Nothing :: Maybe Gio.TlsInteraction.TlsInteraction) #if ENABLE_OVERLOADING data TlsConnectionInteractionPropertyInfo instance AttrInfo TlsConnectionInteractionPropertyInfo where type AttrAllowedOps TlsConnectionInteractionPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TlsConnectionInteractionPropertyInfo = Gio.TlsInteraction.IsTlsInteraction type AttrBaseTypeConstraint TlsConnectionInteractionPropertyInfo = IsTlsConnection type AttrGetType TlsConnectionInteractionPropertyInfo = Gio.TlsInteraction.TlsInteraction type AttrLabel TlsConnectionInteractionPropertyInfo = "interaction" type AttrOrigin TlsConnectionInteractionPropertyInfo = TlsConnection attrGet _ = getTlsConnectionInteraction attrSet _ = setTlsConnectionInteraction attrConstruct _ = constructTlsConnectionInteraction attrClear _ = clearTlsConnectionInteraction #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' tlsConnection #negotiatedProtocol @ -} getTlsConnectionNegotiatedProtocol :: (MonadIO m, IsTlsConnection o) => o -> m (Maybe T.Text) getTlsConnectionNegotiatedProtocol obj = liftIO $ B.Properties.getObjectPropertyString obj "negotiated-protocol" #if ENABLE_OVERLOADING data TlsConnectionNegotiatedProtocolPropertyInfo instance AttrInfo TlsConnectionNegotiatedProtocolPropertyInfo where type AttrAllowedOps TlsConnectionNegotiatedProtocolPropertyInfo = '[ 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TlsConnectionNegotiatedProtocolPropertyInfo = (~) () type AttrBaseTypeConstraint TlsConnectionNegotiatedProtocolPropertyInfo = IsTlsConnection type AttrGetType TlsConnectionNegotiatedProtocolPropertyInfo = (Maybe T.Text) type AttrLabel TlsConnectionNegotiatedProtocolPropertyInfo = "negotiated-protocol" type AttrOrigin TlsConnectionNegotiatedProtocolPropertyInfo = TlsConnection attrGet _ = getTlsConnectionNegotiatedProtocol 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' tlsConnection #peerCertificate @ -} getTlsConnectionPeerCertificate :: (MonadIO m, IsTlsConnection o) => o -> m Gio.TlsCertificate.TlsCertificate getTlsConnectionPeerCertificate obj = liftIO $ checkUnexpectedNothing "getTlsConnectionPeerCertificate" $ B.Properties.getObjectPropertyObject obj "peer-certificate" Gio.TlsCertificate.TlsCertificate #if ENABLE_OVERLOADING data TlsConnectionPeerCertificatePropertyInfo instance AttrInfo TlsConnectionPeerCertificatePropertyInfo where type AttrAllowedOps TlsConnectionPeerCertificatePropertyInfo = '[ 'AttrGet, 'AttrClear] type AttrSetTypeConstraint TlsConnectionPeerCertificatePropertyInfo = (~) () type AttrBaseTypeConstraint TlsConnectionPeerCertificatePropertyInfo = IsTlsConnection type AttrGetType TlsConnectionPeerCertificatePropertyInfo = Gio.TlsCertificate.TlsCertificate type AttrLabel TlsConnectionPeerCertificatePropertyInfo = "peer-certificate" type AttrOrigin TlsConnectionPeerCertificatePropertyInfo = TlsConnection attrGet _ = getTlsConnectionPeerCertificate 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' tlsConnection #peerCertificateErrors @ -} getTlsConnectionPeerCertificateErrors :: (MonadIO m, IsTlsConnection o) => o -> m [Gio.Flags.TlsCertificateFlags] getTlsConnectionPeerCertificateErrors obj = liftIO $ B.Properties.getObjectPropertyFlags obj "peer-certificate-errors" #if ENABLE_OVERLOADING data TlsConnectionPeerCertificateErrorsPropertyInfo instance AttrInfo TlsConnectionPeerCertificateErrorsPropertyInfo where type AttrAllowedOps TlsConnectionPeerCertificateErrorsPropertyInfo = '[ 'AttrGet] type AttrSetTypeConstraint TlsConnectionPeerCertificateErrorsPropertyInfo = (~) () type AttrBaseTypeConstraint TlsConnectionPeerCertificateErrorsPropertyInfo = IsTlsConnection type AttrGetType TlsConnectionPeerCertificateErrorsPropertyInfo = [Gio.Flags.TlsCertificateFlags] type AttrLabel TlsConnectionPeerCertificateErrorsPropertyInfo = "peer-certificate-errors" type AttrOrigin TlsConnectionPeerCertificateErrorsPropertyInfo = TlsConnection attrGet _ = getTlsConnectionPeerCertificateErrors 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' tlsConnection #rehandshakeMode @ -} getTlsConnectionRehandshakeMode :: (MonadIO m, IsTlsConnection o) => o -> m Gio.Enums.TlsRehandshakeMode getTlsConnectionRehandshakeMode 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' tlsConnection [ #rehandshakeMode 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsConnectionRehandshakeMode :: (MonadIO m, IsTlsConnection o) => o -> Gio.Enums.TlsRehandshakeMode -> m () setTlsConnectionRehandshakeMode 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`. -} constructTlsConnectionRehandshakeMode :: (IsTlsConnection o) => Gio.Enums.TlsRehandshakeMode -> IO (GValueConstruct o) constructTlsConnectionRehandshakeMode val = B.Properties.constructObjectPropertyEnum "rehandshake-mode" val #if ENABLE_OVERLOADING data TlsConnectionRehandshakeModePropertyInfo instance AttrInfo TlsConnectionRehandshakeModePropertyInfo where type AttrAllowedOps TlsConnectionRehandshakeModePropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TlsConnectionRehandshakeModePropertyInfo = (~) Gio.Enums.TlsRehandshakeMode type AttrBaseTypeConstraint TlsConnectionRehandshakeModePropertyInfo = IsTlsConnection type AttrGetType TlsConnectionRehandshakeModePropertyInfo = Gio.Enums.TlsRehandshakeMode type AttrLabel TlsConnectionRehandshakeModePropertyInfo = "rehandshake-mode" type AttrOrigin TlsConnectionRehandshakeModePropertyInfo = TlsConnection attrGet _ = getTlsConnectionRehandshakeMode attrSet _ = setTlsConnectionRehandshakeMode attrConstruct _ = constructTlsConnectionRehandshakeMode 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' tlsConnection #requireCloseNotify @ -} getTlsConnectionRequireCloseNotify :: (MonadIO m, IsTlsConnection o) => o -> m Bool getTlsConnectionRequireCloseNotify 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' tlsConnection [ #requireCloseNotify 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsConnectionRequireCloseNotify :: (MonadIO m, IsTlsConnection o) => o -> Bool -> m () setTlsConnectionRequireCloseNotify 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`. -} constructTlsConnectionRequireCloseNotify :: (IsTlsConnection o) => Bool -> IO (GValueConstruct o) constructTlsConnectionRequireCloseNotify val = B.Properties.constructObjectPropertyBool "require-close-notify" val #if ENABLE_OVERLOADING data TlsConnectionRequireCloseNotifyPropertyInfo instance AttrInfo TlsConnectionRequireCloseNotifyPropertyInfo where type AttrAllowedOps TlsConnectionRequireCloseNotifyPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TlsConnectionRequireCloseNotifyPropertyInfo = (~) Bool type AttrBaseTypeConstraint TlsConnectionRequireCloseNotifyPropertyInfo = IsTlsConnection type AttrGetType TlsConnectionRequireCloseNotifyPropertyInfo = Bool type AttrLabel TlsConnectionRequireCloseNotifyPropertyInfo = "require-close-notify" type AttrOrigin TlsConnectionRequireCloseNotifyPropertyInfo = TlsConnection attrGet _ = getTlsConnectionRequireCloseNotify attrSet _ = setTlsConnectionRequireCloseNotify attrConstruct _ = constructTlsConnectionRequireCloseNotify attrClear _ = undefined #endif -- VVV Prop "use-system-certdb" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Just False,Just False) {- | Get the value of the “@use-system-certdb@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' tlsConnection #useSystemCertdb @ -} getTlsConnectionUseSystemCertdb :: (MonadIO m, IsTlsConnection o) => o -> m Bool getTlsConnectionUseSystemCertdb obj = liftIO $ B.Properties.getObjectPropertyBool obj "use-system-certdb" {- | Set the value of the “@use-system-certdb@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' tlsConnection [ #useSystemCertdb 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsConnectionUseSystemCertdb :: (MonadIO m, IsTlsConnection o) => o -> Bool -> m () setTlsConnectionUseSystemCertdb obj val = liftIO $ B.Properties.setObjectPropertyBool obj "use-system-certdb" val {- | Construct a `GValueConstruct` with valid value for the “@use-system-certdb@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructTlsConnectionUseSystemCertdb :: (IsTlsConnection o) => Bool -> IO (GValueConstruct o) constructTlsConnectionUseSystemCertdb val = B.Properties.constructObjectPropertyBool "use-system-certdb" val #if ENABLE_OVERLOADING data TlsConnectionUseSystemCertdbPropertyInfo instance AttrInfo TlsConnectionUseSystemCertdbPropertyInfo where type AttrAllowedOps TlsConnectionUseSystemCertdbPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TlsConnectionUseSystemCertdbPropertyInfo = (~) Bool type AttrBaseTypeConstraint TlsConnectionUseSystemCertdbPropertyInfo = IsTlsConnection type AttrGetType TlsConnectionUseSystemCertdbPropertyInfo = Bool type AttrLabel TlsConnectionUseSystemCertdbPropertyInfo = "use-system-certdb" type AttrOrigin TlsConnectionUseSystemCertdbPropertyInfo = TlsConnection attrGet _ = getTlsConnectionUseSystemCertdb attrSet _ = setTlsConnectionUseSystemCertdb attrConstruct _ = constructTlsConnectionUseSystemCertdb attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList TlsConnection type instance O.AttributeList TlsConnection = TlsConnectionAttributeList type TlsConnectionAttributeList = ('[ '("advertisedProtocols", TlsConnectionAdvertisedProtocolsPropertyInfo), '("baseIoStream", TlsConnectionBaseIoStreamPropertyInfo), '("certificate", TlsConnectionCertificatePropertyInfo), '("closed", Gio.IOStream.IOStreamClosedPropertyInfo), '("database", TlsConnectionDatabasePropertyInfo), '("inputStream", Gio.IOStream.IOStreamInputStreamPropertyInfo), '("interaction", TlsConnectionInteractionPropertyInfo), '("negotiatedProtocol", TlsConnectionNegotiatedProtocolPropertyInfo), '("outputStream", Gio.IOStream.IOStreamOutputStreamPropertyInfo), '("peerCertificate", TlsConnectionPeerCertificatePropertyInfo), '("peerCertificateErrors", TlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshakeMode", TlsConnectionRehandshakeModePropertyInfo), '("requireCloseNotify", TlsConnectionRequireCloseNotifyPropertyInfo), '("useSystemCertdb", TlsConnectionUseSystemCertdbPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING tlsConnectionAdvertisedProtocols :: AttrLabelProxy "advertisedProtocols" tlsConnectionAdvertisedProtocols = AttrLabelProxy tlsConnectionBaseIoStream :: AttrLabelProxy "baseIoStream" tlsConnectionBaseIoStream = AttrLabelProxy tlsConnectionCertificate :: AttrLabelProxy "certificate" tlsConnectionCertificate = AttrLabelProxy tlsConnectionDatabase :: AttrLabelProxy "database" tlsConnectionDatabase = AttrLabelProxy tlsConnectionInteraction :: AttrLabelProxy "interaction" tlsConnectionInteraction = AttrLabelProxy tlsConnectionNegotiatedProtocol :: AttrLabelProxy "negotiatedProtocol" tlsConnectionNegotiatedProtocol = AttrLabelProxy tlsConnectionPeerCertificate :: AttrLabelProxy "peerCertificate" tlsConnectionPeerCertificate = AttrLabelProxy tlsConnectionPeerCertificateErrors :: AttrLabelProxy "peerCertificateErrors" tlsConnectionPeerCertificateErrors = AttrLabelProxy tlsConnectionRehandshakeMode :: AttrLabelProxy "rehandshakeMode" tlsConnectionRehandshakeMode = AttrLabelProxy tlsConnectionRequireCloseNotify :: AttrLabelProxy "requireCloseNotify" tlsConnectionRequireCloseNotify = AttrLabelProxy tlsConnectionUseSystemCertdb :: AttrLabelProxy "useSystemCertdb" tlsConnectionUseSystemCertdb = AttrLabelProxy #endif #if ENABLE_OVERLOADING data TlsConnectionAcceptCertificateSignalInfo instance SignalInfo TlsConnectionAcceptCertificateSignalInfo where type HaskellCallbackType TlsConnectionAcceptCertificateSignalInfo = TlsConnectionAcceptCertificateCallback connectSignal _ obj cb connectMode = do let cb' = wrap_TlsConnectionAcceptCertificateCallback cb cb'' <- mk_TlsConnectionAcceptCertificateCallback cb' connectSignalFunPtr obj "accept-certificate" cb'' connectMode type instance O.SignalList TlsConnection = TlsConnectionSignalList type TlsConnectionSignalList = ('[ '("acceptCertificate", TlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif -- method TlsConnection::emit_accept_certificate -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_emit_accept_certificate" g_tls_connection_emit_accept_certificate :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.TlsConnection' implementations to emit the 'GI.Gio.Objects.TlsConnection.TlsConnection'::@/accept-certificate/@ signal. /Since: 2.28/ -} tlsConnectionEmitAcceptCertificate :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> 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@/ -} tlsConnectionEmitAcceptCertificate conn peerCert errors = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn peerCert' <- unsafeManagedPtrCastPtr peerCert let errors' = gflagsToWord errors result <- g_tls_connection_emit_accept_certificate conn' peerCert' errors' let result' = (/= 0) result touchManagedPtr conn touchManagedPtr peerCert return result' #if ENABLE_OVERLOADING data TlsConnectionEmitAcceptCertificateMethodInfo instance (signature ~ (b -> [Gio.Flags.TlsCertificateFlags] -> m Bool), MonadIO m, IsTlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo TlsConnectionEmitAcceptCertificateMethodInfo a signature where overloadedMethod _ = tlsConnectionEmitAcceptCertificate #endif -- method TlsConnection::get_certificate -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_get_certificate" g_tls_connection_get_certificate :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) IO (Ptr Gio.TlsCertificate.TlsCertificate) {- | Gets /@conn@/\'s certificate, as set by 'GI.Gio.Objects.TlsConnection.tlsConnectionSetCertificate'. /Since: 2.28/ -} tlsConnectionGetCertificate :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> m Gio.TlsCertificate.TlsCertificate {- ^ __Returns:__ /@conn@/\'s certificate, or 'Nothing' -} tlsConnectionGetCertificate conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_certificate conn' checkUnexpectedReturnNULL "tlsConnectionGetCertificate" result result' <- (newObject Gio.TlsCertificate.TlsCertificate) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsConnectionGetCertificateMethodInfo instance (signature ~ (m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetCertificateMethodInfo a signature where overloadedMethod _ = tlsConnectionGetCertificate #endif -- method TlsConnection::get_database -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_get_database" g_tls_connection_get_database :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) IO (Ptr Gio.TlsDatabase.TlsDatabase) {- | Gets the certificate database that /@conn@/ uses to verify peer certificates. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetDatabase'. /Since: 2.30/ -} tlsConnectionGetDatabase :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> m Gio.TlsDatabase.TlsDatabase {- ^ __Returns:__ the certificate database that /@conn@/ uses or 'Nothing' -} tlsConnectionGetDatabase conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_database conn' checkUnexpectedReturnNULL "tlsConnectionGetDatabase" result result' <- (newObject Gio.TlsDatabase.TlsDatabase) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsConnectionGetDatabaseMethodInfo instance (signature ~ (m Gio.TlsDatabase.TlsDatabase), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetDatabaseMethodInfo a signature where overloadedMethod _ = tlsConnectionGetDatabase #endif -- method TlsConnection::get_interaction -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), 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_tls_connection_get_interaction" g_tls_connection_get_interaction :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.30/ -} tlsConnectionGetInteraction :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a connection -} -> m Gio.TlsInteraction.TlsInteraction {- ^ __Returns:__ The interaction object. -} tlsConnectionGetInteraction conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_interaction conn' checkUnexpectedReturnNULL "tlsConnectionGetInteraction" result result' <- (newObject Gio.TlsInteraction.TlsInteraction) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsConnectionGetInteractionMethodInfo instance (signature ~ (m Gio.TlsInteraction.TlsInteraction), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetInteractionMethodInfo a signature where overloadedMethod _ = tlsConnectionGetInteraction #endif -- method TlsConnection::get_negotiated_protocol -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_get_negotiated_protocol" g_tls_connection_get_negotiated_protocol :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.tlsConnectionSetAdvertisedProtocols'. /Since: 2.60/ -} tlsConnectionGetNegotiatedProtocol :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> m (Maybe T.Text) {- ^ __Returns:__ the negotiated protocol, or 'Nothing' -} tlsConnectionGetNegotiatedProtocol conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_negotiated_protocol conn' maybeResult <- convertIfNonNull result $ \result' -> do result'' <- cstringToText result' return result'' touchManagedPtr conn return maybeResult #if ENABLE_OVERLOADING data TlsConnectionGetNegotiatedProtocolMethodInfo instance (signature ~ (m (Maybe T.Text)), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetNegotiatedProtocolMethodInfo a signature where overloadedMethod _ = tlsConnectionGetNegotiatedProtocol #endif -- method TlsConnection::get_peer_certificate -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_get_peer_certificate" g_tls_connection_get_peer_certificate :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.TlsConnection'::@/accept-certificate/@.) /Since: 2.28/ -} tlsConnectionGetPeerCertificate :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> m Gio.TlsCertificate.TlsCertificate {- ^ __Returns:__ /@conn@/\'s peer\'s certificate, or 'Nothing' -} tlsConnectionGetPeerCertificate conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_peer_certificate conn' checkUnexpectedReturnNULL "tlsConnectionGetPeerCertificate" result result' <- (newObject Gio.TlsCertificate.TlsCertificate) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsConnectionGetPeerCertificateMethodInfo instance (signature ~ (m Gio.TlsCertificate.TlsCertificate), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetPeerCertificateMethodInfo a signature where overloadedMethod _ = tlsConnectionGetPeerCertificate #endif -- method TlsConnection::get_peer_certificate_errors -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_get_peer_certificate_errors" g_tls_connection_get_peer_certificate_errors :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.TlsConnection'::@/accept-certificate/@.) /Since: 2.28/ -} tlsConnectionGetPeerCertificateErrors :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> m [Gio.Flags.TlsCertificateFlags] {- ^ __Returns:__ /@conn@/\'s peer\'s certificate errors -} tlsConnectionGetPeerCertificateErrors conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_peer_certificate_errors conn' let result' = wordToGFlags result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsConnectionGetPeerCertificateErrorsMethodInfo instance (signature ~ (m [Gio.Flags.TlsCertificateFlags]), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetPeerCertificateErrorsMethodInfo a signature where overloadedMethod _ = tlsConnectionGetPeerCertificateErrors #endif -- method TlsConnection::get_rehandshake_mode -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_get_rehandshake_mode" g_tls_connection_get_rehandshake_mode :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) IO CUInt {-# DEPRECATED tlsConnectionGetRehandshakeMode ["(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."] #-} {- | Gets /@conn@/ rehandshaking mode. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetRehandshakeMode' for details. /Since: 2.28/ -} tlsConnectionGetRehandshakeMode :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> m Gio.Enums.TlsRehandshakeMode {- ^ __Returns:__ /@conn@/\'s rehandshaking mode -} tlsConnectionGetRehandshakeMode conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_rehandshake_mode conn' let result' = (toEnum . fromIntegral) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsConnectionGetRehandshakeModeMethodInfo instance (signature ~ (m Gio.Enums.TlsRehandshakeMode), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetRehandshakeModeMethodInfo a signature where overloadedMethod _ = tlsConnectionGetRehandshakeMode #endif -- method TlsConnection::get_require_close_notify -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_get_require_close_notify" g_tls_connection_get_require_close_notify :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) IO CInt {- | Tests whether or not /@conn@/ expects a proper TLS close notification when the connection is closed. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetRequireCloseNotify' for details. /Since: 2.28/ -} tlsConnectionGetRequireCloseNotify :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> m Bool {- ^ __Returns:__ 'True' if /@conn@/ requires a proper TLS close notification. -} tlsConnectionGetRequireCloseNotify conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_require_close_notify conn' let result' = (/= 0) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsConnectionGetRequireCloseNotifyMethodInfo instance (signature ~ (m Bool), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetRequireCloseNotifyMethodInfo a signature where overloadedMethod _ = tlsConnectionGetRequireCloseNotify #endif -- method TlsConnection::get_use_system_certdb -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_get_use_system_certdb" g_tls_connection_get_use_system_certdb :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) IO CInt {-# DEPRECATED tlsConnectionGetUseSystemCertdb ["(Since version 2.30)","Use 'GI.Gio.Objects.TlsConnection.tlsConnectionGetDatabase' instead"] #-} {- | Gets whether /@conn@/ uses the system certificate database to verify peer certificates. See 'GI.Gio.Objects.TlsConnection.tlsConnectionSetUseSystemCertdb'. -} tlsConnectionGetUseSystemCertdb :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> m Bool {- ^ __Returns:__ whether /@conn@/ uses the system certificate database -} tlsConnectionGetUseSystemCertdb conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_connection_get_use_system_certdb conn' let result' = (/= 0) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsConnectionGetUseSystemCertdbMethodInfo instance (signature ~ (m Bool), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionGetUseSystemCertdbMethodInfo a signature where overloadedMethod _ = tlsConnectionGetUseSystemCertdb #endif -- method TlsConnection::handshake -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_handshake" g_tls_connection_handshake :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.TlsConnection' will handle this for you automatically when you try to send or receive data on the connection. However, you can call 'GI.Gio.Objects.TlsConnection.tlsConnectionHandshake' 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@/\'s output stream, 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.Objects.TlsConnection.tlsConnectionHandshake' 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.Objects.TlsConnection.TlsConnection'::@/accept_certificate/@ may be emitted during the handshake. /Since: 2.28/ -} tlsConnectionHandshake :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a, Gio.Cancellable.IsCancellable b) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> Maybe (b) {- ^ /@cancellable@/: a 'GI.Gio.Objects.Cancellable.Cancellable', or 'Nothing' -} -> m () {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} tlsConnectionHandshake 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_tls_connection_handshake conn' maybeCancellable touchManagedPtr conn whenJust cancellable touchManagedPtr return () ) (do return () ) #if ENABLE_OVERLOADING data TlsConnectionHandshakeMethodInfo instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo TlsConnectionHandshakeMethodInfo a signature where overloadedMethod _ = tlsConnectionHandshake #endif -- method TlsConnection::handshake_async -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_handshake_async" g_tls_connection_handshake_async :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.tlsConnectionHandshake' for more information. /Since: 2.28/ -} tlsConnectionHandshakeAsync :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a, Gio.Cancellable.IsCancellable b) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> 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 () tlsConnectionHandshakeAsync 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_tls_connection_handshake_async conn' ioPriority maybeCancellable maybeCallback userData touchManagedPtr conn whenJust cancellable touchManagedPtr return () #if ENABLE_OVERLOADING data TlsConnectionHandshakeAsyncMethodInfo instance (signature ~ (Int32 -> Maybe (b) -> Maybe (Gio.Callbacks.AsyncReadyCallback) -> m ()), MonadIO m, IsTlsConnection a, Gio.Cancellable.IsCancellable b) => O.MethodInfo TlsConnectionHandshakeAsyncMethodInfo a signature where overloadedMethod _ = tlsConnectionHandshakeAsync #endif -- method TlsConnection::handshake_finish -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_handshake_finish" g_tls_connection_handshake_finish :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.tlsConnectionHandshake' for more information. /Since: 2.28/ -} tlsConnectionHandshakeFinish :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a, Gio.AsyncResult.IsAsyncResult b) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> b {- ^ /@result@/: a 'GI.Gio.Interfaces.AsyncResult.AsyncResult'. -} -> m () {- ^ /(Can throw 'Data.GI.Base.GError.GError')/ -} tlsConnectionHandshakeFinish conn result_ = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result_' <- unsafeManagedPtrCastPtr result_ onException (do _ <- propagateGError $ g_tls_connection_handshake_finish conn' result_' touchManagedPtr conn touchManagedPtr result_ return () ) (do return () ) #if ENABLE_OVERLOADING data TlsConnectionHandshakeFinishMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsTlsConnection a, Gio.AsyncResult.IsAsyncResult b) => O.MethodInfo TlsConnectionHandshakeFinishMethodInfo a signature where overloadedMethod _ = tlsConnectionHandshakeFinish #endif -- method TlsConnection::set_advertised_protocols -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_set_advertised_protocols" g_tls_connection_set_advertised_protocols :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.tlsConnectionGetNegotiatedProtocol' 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/ -} tlsConnectionSetAdvertisedProtocols :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> Maybe ([T.Text]) {- ^ /@protocols@/: a 'Nothing'-terminated array of ALPN protocol names (eg, \"http\/1.1\", \"h2\"), or 'Nothing' -} -> m () tlsConnectionSetAdvertisedProtocols conn protocols = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn maybeProtocols <- case protocols of Nothing -> return nullPtr Just jProtocols -> do jProtocols' <- packZeroTerminatedUTF8CArray jProtocols return jProtocols' g_tls_connection_set_advertised_protocols conn' maybeProtocols touchManagedPtr conn mapZeroTerminatedCArray freeMem maybeProtocols freeMem maybeProtocols return () #if ENABLE_OVERLOADING data TlsConnectionSetAdvertisedProtocolsMethodInfo instance (signature ~ (Maybe ([T.Text]) -> m ()), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionSetAdvertisedProtocolsMethodInfo a signature where overloadedMethod _ = tlsConnectionSetAdvertisedProtocols #endif -- method TlsConnection::set_certificate -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_set_certificate" g_tls_connection_set_certificate :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.TlsServerConnection.TlsServerConnection', it is mandatory to set this, and that will normally be done at construct time. For a 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection', 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.TlsClientConnection.tlsClientConnectionGetAcceptedCas' 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.TlsClientConnection.tlsClientConnectionGetAcceptedCas' will return non-'Nothing'.) /Since: 2.28/ -} tlsConnectionSetCertificate :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> b {- ^ /@certificate@/: the certificate to use for /@conn@/ -} -> m () tlsConnectionSetCertificate conn certificate = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn certificate' <- unsafeManagedPtrCastPtr certificate g_tls_connection_set_certificate conn' certificate' touchManagedPtr conn touchManagedPtr certificate return () #if ENABLE_OVERLOADING data TlsConnectionSetCertificateMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsTlsConnection a, Gio.TlsCertificate.IsTlsCertificate b) => O.MethodInfo TlsConnectionSetCertificateMethodInfo a signature where overloadedMethod _ = tlsConnectionSetCertificate #endif -- method TlsConnection::set_database -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_set_database" g_tls_connection_set_database :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.Objects.TlsConnection.TlsConnection'::@/accept-certificate/@ will always be emitted on client-side connections, unless that bit is not set in 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection':@/validation-flags/@). /Since: 2.30/ -} tlsConnectionSetDatabase :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a, Gio.TlsDatabase.IsTlsDatabase b) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> b {- ^ /@database@/: a 'GI.Gio.Objects.TlsDatabase.TlsDatabase' -} -> m () tlsConnectionSetDatabase conn database = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn database' <- unsafeManagedPtrCastPtr database g_tls_connection_set_database conn' database' touchManagedPtr conn touchManagedPtr database return () #if ENABLE_OVERLOADING data TlsConnectionSetDatabaseMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsTlsConnection a, Gio.TlsDatabase.IsTlsDatabase b) => O.MethodInfo TlsConnectionSetDatabaseMethodInfo a signature where overloadedMethod _ = tlsConnectionSetDatabase #endif -- method TlsConnection::set_interaction -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), 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_tls_connection_set_interaction" g_tls_connection_set_interaction :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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.30/ -} tlsConnectionSetInteraction :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a, Gio.TlsInteraction.IsTlsInteraction b) => a {- ^ /@conn@/: a connection -} -> Maybe (b) {- ^ /@interaction@/: an interaction object, or 'Nothing' -} -> m () tlsConnectionSetInteraction conn interaction = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn maybeInteraction <- case interaction of Nothing -> return nullPtr Just jInteraction -> do jInteraction' <- unsafeManagedPtrCastPtr jInteraction return jInteraction' g_tls_connection_set_interaction conn' maybeInteraction touchManagedPtr conn whenJust interaction touchManagedPtr return () #if ENABLE_OVERLOADING data TlsConnectionSetInteractionMethodInfo instance (signature ~ (Maybe (b) -> m ()), MonadIO m, IsTlsConnection a, Gio.TlsInteraction.IsTlsInteraction b) => O.MethodInfo TlsConnectionSetInteractionMethodInfo a signature where overloadedMethod _ = tlsConnectionSetInteraction #endif -- method TlsConnection::set_rehandshake_mode -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_set_rehandshake_mode" g_tls_connection_set_rehandshake_mode :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) CUInt -> -- mode : TInterface (Name {namespace = "Gio", name = "TlsRehandshakeMode"}) IO () {-# DEPRECATED tlsConnectionSetRehandshakeMode ["(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, when TLS 1.2 or older is in use. '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.28/ -} tlsConnectionSetRehandshakeMode :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> Gio.Enums.TlsRehandshakeMode {- ^ /@mode@/: the rehandshaking mode -} -> m () tlsConnectionSetRehandshakeMode conn mode = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn let mode' = (fromIntegral . fromEnum) mode g_tls_connection_set_rehandshake_mode conn' mode' touchManagedPtr conn return () #if ENABLE_OVERLOADING data TlsConnectionSetRehandshakeModeMethodInfo instance (signature ~ (Gio.Enums.TlsRehandshakeMode -> m ()), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionSetRehandshakeModeMethodInfo a signature where overloadedMethod _ = tlsConnectionSetRehandshakeMode #endif -- method TlsConnection::set_require_close_notify -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", 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_tls_connection_set_require_close_notify" g_tls_connection_set_require_close_notify :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) 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 sometimes omitted. (TLS 1.1 explicitly allows this; in TLS 1.0 it is technically an error, but often done anyway.) You can use 'GI.Gio.Objects.TlsConnection.tlsConnectionSetRequireCloseNotify' 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.Objects.SocketConnection.SocketConnection', 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.Objects.IOStream.iOStreamClose' itself on /@conn@/, 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.Objects.TlsConnection.TlsConnection':@/base-io-stream/@ rather than closing /@conn@/ itself, but note that this may only be done when no other operations are pending on /@conn@/ or the base I\/O stream. /Since: 2.28/ -} tlsConnectionSetRequireCloseNotify :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> Bool {- ^ /@requireCloseNotify@/: whether or not to require close notification -} -> m () tlsConnectionSetRequireCloseNotify conn requireCloseNotify = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn let requireCloseNotify' = (fromIntegral . fromEnum) requireCloseNotify g_tls_connection_set_require_close_notify conn' requireCloseNotify' touchManagedPtr conn return () #if ENABLE_OVERLOADING data TlsConnectionSetRequireCloseNotifyMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionSetRequireCloseNotifyMethodInfo a signature where overloadedMethod _ = tlsConnectionSetRequireCloseNotify #endif -- method TlsConnection::set_use_system_certdb -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use_system_certdb", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to use the system certificate database", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Nothing -- throws : False -- Skip return : False foreign import ccall "g_tls_connection_set_use_system_certdb" g_tls_connection_set_use_system_certdb :: Ptr TlsConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsConnection"}) CInt -> -- use_system_certdb : TBasicType TBoolean IO () {-# DEPRECATED tlsConnectionSetUseSystemCertdb ["(Since version 2.30)","Use 'GI.Gio.Objects.TlsConnection.tlsConnectionSetDatabase' instead"] #-} {- | Sets whether /@conn@/ uses the system certificate database to verify peer certificates. This is 'True' by default. If set to 'False', then peer certificate validation will always set the 'GI.Gio.Flags.TlsCertificateFlagsUnknownCa' error (meaning 'GI.Gio.Objects.TlsConnection.TlsConnection'::@/accept-certificate/@ will always be emitted on client-side connections, unless that bit is not set in 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection':@/validation-flags/@). -} tlsConnectionSetUseSystemCertdb :: (B.CallStack.HasCallStack, MonadIO m, IsTlsConnection a) => a {- ^ /@conn@/: a 'GI.Gio.Objects.TlsConnection.TlsConnection' -} -> Bool {- ^ /@useSystemCertdb@/: whether to use the system certificate database -} -> m () tlsConnectionSetUseSystemCertdb conn useSystemCertdb = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn let useSystemCertdb' = (fromIntegral . fromEnum) useSystemCertdb g_tls_connection_set_use_system_certdb conn' useSystemCertdb' touchManagedPtr conn return () #if ENABLE_OVERLOADING data TlsConnectionSetUseSystemCertdbMethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsTlsConnection a) => O.MethodInfo TlsConnectionSetUseSystemCertdbMethodInfo a signature where overloadedMethod _ = tlsConnectionSetUseSystemCertdb #endif