{- | Copyright : Will Thompson, Iñaki García Etxebarria and Jonas Platte License : LGPL-2.1 Maintainer : Iñaki García Etxebarria (inaki@blueleaf.cc) 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' is the client-side subclass of 'GI.Gio.Objects.TlsConnection.TlsConnection', representing a client-side TLS connection. /Since: 2.28/ -} #define ENABLE_OVERLOADING (MIN_VERSION_haskell_gi_overloading(1,0,0) \ && !defined(__HADDOCK_VERSION__)) module GI.Gio.Interfaces.TlsClientConnection ( -- * Exported types TlsClientConnection(..) , noTlsClientConnection , IsTlsClientConnection , toTlsClientConnection , -- * Methods -- ** copySessionState #method:copySessionState# #if ENABLE_OVERLOADING TlsClientConnectionCopySessionStateMethodInfo, #endif tlsClientConnectionCopySessionState , -- ** getAcceptedCas #method:getAcceptedCas# #if ENABLE_OVERLOADING TlsClientConnectionGetAcceptedCasMethodInfo, #endif tlsClientConnectionGetAcceptedCas , -- ** getServerIdentity #method:getServerIdentity# #if ENABLE_OVERLOADING TlsClientConnectionGetServerIdentityMethodInfo, #endif tlsClientConnectionGetServerIdentity , -- ** getUseSsl3 #method:getUseSsl3# #if ENABLE_OVERLOADING TlsClientConnectionGetUseSsl3MethodInfo , #endif tlsClientConnectionGetUseSsl3 , -- ** getValidationFlags #method:getValidationFlags# #if ENABLE_OVERLOADING TlsClientConnectionGetValidationFlagsMethodInfo, #endif tlsClientConnectionGetValidationFlags , -- ** new #method:new# tlsClientConnectionNew , -- ** setServerIdentity #method:setServerIdentity# #if ENABLE_OVERLOADING TlsClientConnectionSetServerIdentityMethodInfo, #endif tlsClientConnectionSetServerIdentity , -- ** setUseSsl3 #method:setUseSsl3# #if ENABLE_OVERLOADING TlsClientConnectionSetUseSsl3MethodInfo , #endif tlsClientConnectionSetUseSsl3 , -- ** setValidationFlags #method:setValidationFlags# #if ENABLE_OVERLOADING TlsClientConnectionSetValidationFlagsMethodInfo, #endif tlsClientConnectionSetValidationFlags , -- * Properties -- ** acceptedCas #attr:acceptedCas# {- | A list of the distinguished names of the Certificate Authorities that the server will accept client certificates signed by. If the server requests a client certificate during the handshake, then this property will be set after the handshake completes. Each item in the list is a 'GI.GLib.Structs.ByteArray.ByteArray' which contains the complete subject DN of the certificate authority. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsClientConnectionAcceptedCasPropertyInfo, #endif getTlsClientConnectionAcceptedCas , #if ENABLE_OVERLOADING tlsClientConnectionAcceptedCas , #endif -- ** serverIdentity #attr:serverIdentity# {- | A 'GI.Gio.Interfaces.SocketConnectable.SocketConnectable' describing the identity of the server that is expected on the other end of the connection. If the 'GI.Gio.Flags.TlsCertificateFlagsBadIdentity' flag is set in 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection':@/validation-flags/@, this object will be used to determine the expected identify of the remote end of the connection; if 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection':@/server-identity/@ is not set, or does not match the identity presented by the server, then the 'GI.Gio.Flags.TlsCertificateFlagsBadIdentity' validation will fail. In addition to its use in verifying the server certificate, this is also used to give a hint to the server about what certificate we expect, which is useful for servers that serve virtual hosts. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsClientConnectionServerIdentityPropertyInfo, #endif constructTlsClientConnectionServerIdentity, getTlsClientConnectionServerIdentity , setTlsClientConnectionServerIdentity , #if ENABLE_OVERLOADING tlsClientConnectionServerIdentity , #endif -- ** useSsl3 #attr:useSsl3# {- | If 'True', forces the connection to use a fallback version of TLS or SSL, rather than trying to negotiate the best version of TLS to use. See 'GI.Gio.Interfaces.TlsClientConnection.tlsClientConnectionSetUseSsl3'. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsClientConnectionUseSsl3PropertyInfo , #endif constructTlsClientConnectionUseSsl3 , getTlsClientConnectionUseSsl3 , setTlsClientConnectionUseSsl3 , #if ENABLE_OVERLOADING tlsClientConnectionUseSsl3 , #endif -- ** validationFlags #attr:validationFlags# {- | What steps to perform when validating a certificate received from a server. Server certificates that fail to validate in all of the ways indicated here will be rejected unless the application overrides the default via 'GI.Gio.Objects.TlsConnection.TlsConnection'::@/accept-certificate/@. /Since: 2.28/ -} #if ENABLE_OVERLOADING TlsClientConnectionValidationFlagsPropertyInfo, #endif constructTlsClientConnectionValidationFlags, getTlsClientConnectionValidationFlags , setTlsClientConnectionValidationFlags , #if ENABLE_OVERLOADING tlsClientConnectionValidationFlags , #endif ) 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 {-# SOURCE #-} qualified GI.Gio.Flags as Gio.Flags import {-# SOURCE #-} qualified GI.Gio.Interfaces.SocketConnectable as Gio.SocketConnectable import {-# SOURCE #-} qualified GI.Gio.Objects.IOStream as Gio.IOStream import {-# SOURCE #-} qualified GI.Gio.Objects.TlsConnection as Gio.TlsConnection -- interface TlsClientConnection -- | Memory-managed wrapper type. newtype TlsClientConnection = TlsClientConnection (ManagedPtr TlsClientConnection) -- | A convenience alias for `Nothing` :: `Maybe` `TlsClientConnection`. noTlsClientConnection :: Maybe TlsClientConnection noTlsClientConnection = Nothing #if ENABLE_OVERLOADING type instance O.SignalList TlsClientConnection = TlsClientConnectionSignalList type TlsClientConnectionSignalList = ('[ '("acceptCertificate", Gio.TlsConnection.TlsConnectionAcceptCertificateSignalInfo), '("notify", GObject.Object.ObjectNotifySignalInfo)] :: [(Symbol, *)]) #endif foreign import ccall "g_tls_client_connection_get_type" c_g_tls_client_connection_get_type :: IO GType instance GObject TlsClientConnection where gobjectType = c_g_tls_client_connection_get_type -- | Type class for types which can be safely cast to `TlsClientConnection`, for instance with `toTlsClientConnection`. class (GObject o, O.IsDescendantOf TlsClientConnection o) => IsTlsClientConnection o instance (GObject o, O.IsDescendantOf TlsClientConnection o) => IsTlsClientConnection o instance O.HasParentTypes TlsClientConnection type instance O.ParentTypes TlsClientConnection = '[GObject.Object.Object, Gio.TlsConnection.TlsConnection, Gio.IOStream.IOStream] -- | Cast to `TlsClientConnection`, for types for which this is known to be safe. For general casts, use `Data.GI.Base.ManagedPtr.castTo`. toTlsClientConnection :: (MonadIO m, IsTlsClientConnection o) => o -> m TlsClientConnection toTlsClientConnection = liftIO . unsafeCastTo TlsClientConnection -- VVV Prop "accepted-cas" -- Type: TGList (TBasicType TPtr) -- Flags: [PropertyReadable] -- Nullable: (Nothing,Nothing) {- | Get the value of the “@accepted-cas@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' tlsClientConnection #acceptedCas @ -} getTlsClientConnectionAcceptedCas :: (MonadIO m, IsTlsClientConnection o) => o -> m ([Ptr ()]) getTlsClientConnectionAcceptedCas obj = liftIO $ B.Properties.getObjectPropertyPtrGList obj "accepted-cas" #if ENABLE_OVERLOADING data TlsClientConnectionAcceptedCasPropertyInfo instance AttrInfo TlsClientConnectionAcceptedCasPropertyInfo where type AttrAllowedOps TlsClientConnectionAcceptedCasPropertyInfo = '[ 'AttrGet] type AttrSetTypeConstraint TlsClientConnectionAcceptedCasPropertyInfo = (~) () type AttrBaseTypeConstraint TlsClientConnectionAcceptedCasPropertyInfo = IsTlsClientConnection type AttrGetType TlsClientConnectionAcceptedCasPropertyInfo = ([Ptr ()]) type AttrLabel TlsClientConnectionAcceptedCasPropertyInfo = "accepted-cas" type AttrOrigin TlsClientConnectionAcceptedCasPropertyInfo = TlsClientConnection attrGet _ = getTlsClientConnectionAcceptedCas attrSet _ = undefined attrConstruct _ = undefined attrClear _ = undefined #endif -- VVV Prop "server-identity" -- Type: TInterface (Name {namespace = "Gio", name = "SocketConnectable"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Just False,Just False) {- | Get the value of the “@server-identity@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' tlsClientConnection #serverIdentity @ -} getTlsClientConnectionServerIdentity :: (MonadIO m, IsTlsClientConnection o) => o -> m Gio.SocketConnectable.SocketConnectable getTlsClientConnectionServerIdentity obj = liftIO $ checkUnexpectedNothing "getTlsClientConnectionServerIdentity" $ B.Properties.getObjectPropertyObject obj "server-identity" Gio.SocketConnectable.SocketConnectable {- | Set the value of the “@server-identity@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' tlsClientConnection [ #serverIdentity 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsClientConnectionServerIdentity :: (MonadIO m, IsTlsClientConnection o, Gio.SocketConnectable.IsSocketConnectable a) => o -> a -> m () setTlsClientConnectionServerIdentity obj val = liftIO $ B.Properties.setObjectPropertyObject obj "server-identity" (Just val) {- | Construct a `GValueConstruct` with valid value for the “@server-identity@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructTlsClientConnectionServerIdentity :: (IsTlsClientConnection o, Gio.SocketConnectable.IsSocketConnectable a) => a -> IO (GValueConstruct o) constructTlsClientConnectionServerIdentity val = B.Properties.constructObjectPropertyObject "server-identity" (Just val) #if ENABLE_OVERLOADING data TlsClientConnectionServerIdentityPropertyInfo instance AttrInfo TlsClientConnectionServerIdentityPropertyInfo where type AttrAllowedOps TlsClientConnectionServerIdentityPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TlsClientConnectionServerIdentityPropertyInfo = Gio.SocketConnectable.IsSocketConnectable type AttrBaseTypeConstraint TlsClientConnectionServerIdentityPropertyInfo = IsTlsClientConnection type AttrGetType TlsClientConnectionServerIdentityPropertyInfo = Gio.SocketConnectable.SocketConnectable type AttrLabel TlsClientConnectionServerIdentityPropertyInfo = "server-identity" type AttrOrigin TlsClientConnectionServerIdentityPropertyInfo = TlsClientConnection attrGet _ = getTlsClientConnectionServerIdentity attrSet _ = setTlsClientConnectionServerIdentity attrConstruct _ = constructTlsClientConnectionServerIdentity attrClear _ = undefined #endif -- VVV Prop "use-ssl3" -- Type: TBasicType TBoolean -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Just False,Just False) {- | Get the value of the “@use-ssl3@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' tlsClientConnection #useSsl3 @ -} getTlsClientConnectionUseSsl3 :: (MonadIO m, IsTlsClientConnection o) => o -> m Bool getTlsClientConnectionUseSsl3 obj = liftIO $ B.Properties.getObjectPropertyBool obj "use-ssl3" {- | Set the value of the “@use-ssl3@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' tlsClientConnection [ #useSsl3 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsClientConnectionUseSsl3 :: (MonadIO m, IsTlsClientConnection o) => o -> Bool -> m () setTlsClientConnectionUseSsl3 obj val = liftIO $ B.Properties.setObjectPropertyBool obj "use-ssl3" val {- | Construct a `GValueConstruct` with valid value for the “@use-ssl3@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructTlsClientConnectionUseSsl3 :: (IsTlsClientConnection o) => Bool -> IO (GValueConstruct o) constructTlsClientConnectionUseSsl3 val = B.Properties.constructObjectPropertyBool "use-ssl3" val #if ENABLE_OVERLOADING data TlsClientConnectionUseSsl3PropertyInfo instance AttrInfo TlsClientConnectionUseSsl3PropertyInfo where type AttrAllowedOps TlsClientConnectionUseSsl3PropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TlsClientConnectionUseSsl3PropertyInfo = (~) Bool type AttrBaseTypeConstraint TlsClientConnectionUseSsl3PropertyInfo = IsTlsClientConnection type AttrGetType TlsClientConnectionUseSsl3PropertyInfo = Bool type AttrLabel TlsClientConnectionUseSsl3PropertyInfo = "use-ssl3" type AttrOrigin TlsClientConnectionUseSsl3PropertyInfo = TlsClientConnection attrGet _ = getTlsClientConnectionUseSsl3 attrSet _ = setTlsClientConnectionUseSsl3 attrConstruct _ = constructTlsClientConnectionUseSsl3 attrClear _ = undefined #endif -- VVV Prop "validation-flags" -- Type: TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}) -- Flags: [PropertyReadable,PropertyWritable,PropertyConstruct] -- Nullable: (Just False,Just False) {- | Get the value of the “@validation-flags@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.get' tlsClientConnection #validationFlags @ -} getTlsClientConnectionValidationFlags :: (MonadIO m, IsTlsClientConnection o) => o -> m [Gio.Flags.TlsCertificateFlags] getTlsClientConnectionValidationFlags obj = liftIO $ B.Properties.getObjectPropertyFlags obj "validation-flags" {- | Set the value of the “@validation-flags@” property. When is enabled, this is equivalent to @ 'Data.GI.Base.Attributes.set' tlsClientConnection [ #validationFlags 'Data.GI.Base.Attributes.:=' value ] @ -} setTlsClientConnectionValidationFlags :: (MonadIO m, IsTlsClientConnection o) => o -> [Gio.Flags.TlsCertificateFlags] -> m () setTlsClientConnectionValidationFlags obj val = liftIO $ B.Properties.setObjectPropertyFlags obj "validation-flags" val {- | Construct a `GValueConstruct` with valid value for the “@validation-flags@” property. This is rarely needed directly, but it is used by `Data.GI.Base.Constructible.new`. -} constructTlsClientConnectionValidationFlags :: (IsTlsClientConnection o) => [Gio.Flags.TlsCertificateFlags] -> IO (GValueConstruct o) constructTlsClientConnectionValidationFlags val = B.Properties.constructObjectPropertyFlags "validation-flags" val #if ENABLE_OVERLOADING data TlsClientConnectionValidationFlagsPropertyInfo instance AttrInfo TlsClientConnectionValidationFlagsPropertyInfo where type AttrAllowedOps TlsClientConnectionValidationFlagsPropertyInfo = '[ 'AttrSet, 'AttrConstruct, 'AttrGet] type AttrSetTypeConstraint TlsClientConnectionValidationFlagsPropertyInfo = (~) [Gio.Flags.TlsCertificateFlags] type AttrBaseTypeConstraint TlsClientConnectionValidationFlagsPropertyInfo = IsTlsClientConnection type AttrGetType TlsClientConnectionValidationFlagsPropertyInfo = [Gio.Flags.TlsCertificateFlags] type AttrLabel TlsClientConnectionValidationFlagsPropertyInfo = "validation-flags" type AttrOrigin TlsClientConnectionValidationFlagsPropertyInfo = TlsClientConnection attrGet _ = getTlsClientConnectionValidationFlags attrSet _ = setTlsClientConnectionValidationFlags attrConstruct _ = constructTlsClientConnectionValidationFlags attrClear _ = undefined #endif #if ENABLE_OVERLOADING instance O.HasAttributeList TlsClientConnection type instance O.AttributeList TlsClientConnection = TlsClientConnectionAttributeList type TlsClientConnectionAttributeList = ('[ '("acceptedCas", TlsClientConnectionAcceptedCasPropertyInfo), '("advertisedProtocols", Gio.TlsConnection.TlsConnectionAdvertisedProtocolsPropertyInfo), '("baseIoStream", Gio.TlsConnection.TlsConnectionBaseIoStreamPropertyInfo), '("certificate", Gio.TlsConnection.TlsConnectionCertificatePropertyInfo), '("closed", Gio.IOStream.IOStreamClosedPropertyInfo), '("database", Gio.TlsConnection.TlsConnectionDatabasePropertyInfo), '("inputStream", Gio.IOStream.IOStreamInputStreamPropertyInfo), '("interaction", Gio.TlsConnection.TlsConnectionInteractionPropertyInfo), '("negotiatedProtocol", Gio.TlsConnection.TlsConnectionNegotiatedProtocolPropertyInfo), '("outputStream", Gio.IOStream.IOStreamOutputStreamPropertyInfo), '("peerCertificate", Gio.TlsConnection.TlsConnectionPeerCertificatePropertyInfo), '("peerCertificateErrors", Gio.TlsConnection.TlsConnectionPeerCertificateErrorsPropertyInfo), '("rehandshakeMode", Gio.TlsConnection.TlsConnectionRehandshakeModePropertyInfo), '("requireCloseNotify", Gio.TlsConnection.TlsConnectionRequireCloseNotifyPropertyInfo), '("serverIdentity", TlsClientConnectionServerIdentityPropertyInfo), '("useSsl3", TlsClientConnectionUseSsl3PropertyInfo), '("useSystemCertdb", Gio.TlsConnection.TlsConnectionUseSystemCertdbPropertyInfo), '("validationFlags", TlsClientConnectionValidationFlagsPropertyInfo)] :: [(Symbol, *)]) #endif #if ENABLE_OVERLOADING tlsClientConnectionAcceptedCas :: AttrLabelProxy "acceptedCas" tlsClientConnectionAcceptedCas = AttrLabelProxy tlsClientConnectionServerIdentity :: AttrLabelProxy "serverIdentity" tlsClientConnectionServerIdentity = AttrLabelProxy tlsClientConnectionUseSsl3 :: AttrLabelProxy "useSsl3" tlsClientConnectionUseSsl3 = AttrLabelProxy tlsClientConnectionValidationFlags :: AttrLabelProxy "validationFlags" tlsClientConnectionValidationFlags = AttrLabelProxy #endif #if ENABLE_OVERLOADING type family ResolveTlsClientConnectionMethod (t :: Symbol) (o :: *) :: * where ResolveTlsClientConnectionMethod "bindProperty" o = GObject.Object.ObjectBindPropertyMethodInfo ResolveTlsClientConnectionMethod "bindPropertyFull" o = GObject.Object.ObjectBindPropertyFullMethodInfo ResolveTlsClientConnectionMethod "clearPending" o = Gio.IOStream.IOStreamClearPendingMethodInfo ResolveTlsClientConnectionMethod "close" o = Gio.IOStream.IOStreamCloseMethodInfo ResolveTlsClientConnectionMethod "closeAsync" o = Gio.IOStream.IOStreamCloseAsyncMethodInfo ResolveTlsClientConnectionMethod "closeFinish" o = Gio.IOStream.IOStreamCloseFinishMethodInfo ResolveTlsClientConnectionMethod "copySessionState" o = TlsClientConnectionCopySessionStateMethodInfo ResolveTlsClientConnectionMethod "emitAcceptCertificate" o = Gio.TlsConnection.TlsConnectionEmitAcceptCertificateMethodInfo ResolveTlsClientConnectionMethod "forceFloating" o = GObject.Object.ObjectForceFloatingMethodInfo ResolveTlsClientConnectionMethod "freezeNotify" o = GObject.Object.ObjectFreezeNotifyMethodInfo ResolveTlsClientConnectionMethod "getv" o = GObject.Object.ObjectGetvMethodInfo ResolveTlsClientConnectionMethod "handshake" o = Gio.TlsConnection.TlsConnectionHandshakeMethodInfo ResolveTlsClientConnectionMethod "handshakeAsync" o = Gio.TlsConnection.TlsConnectionHandshakeAsyncMethodInfo ResolveTlsClientConnectionMethod "handshakeFinish" o = Gio.TlsConnection.TlsConnectionHandshakeFinishMethodInfo ResolveTlsClientConnectionMethod "hasPending" o = Gio.IOStream.IOStreamHasPendingMethodInfo ResolveTlsClientConnectionMethod "isClosed" o = Gio.IOStream.IOStreamIsClosedMethodInfo ResolveTlsClientConnectionMethod "isFloating" o = GObject.Object.ObjectIsFloatingMethodInfo ResolveTlsClientConnectionMethod "notify" o = GObject.Object.ObjectNotifyMethodInfo ResolveTlsClientConnectionMethod "notifyByPspec" o = GObject.Object.ObjectNotifyByPspecMethodInfo ResolveTlsClientConnectionMethod "ref" o = GObject.Object.ObjectRefMethodInfo ResolveTlsClientConnectionMethod "refSink" o = GObject.Object.ObjectRefSinkMethodInfo ResolveTlsClientConnectionMethod "runDispose" o = GObject.Object.ObjectRunDisposeMethodInfo ResolveTlsClientConnectionMethod "spliceAsync" o = Gio.IOStream.IOStreamSpliceAsyncMethodInfo ResolveTlsClientConnectionMethod "stealData" o = GObject.Object.ObjectStealDataMethodInfo ResolveTlsClientConnectionMethod "stealQdata" o = GObject.Object.ObjectStealQdataMethodInfo ResolveTlsClientConnectionMethod "thawNotify" o = GObject.Object.ObjectThawNotifyMethodInfo ResolveTlsClientConnectionMethod "unref" o = GObject.Object.ObjectUnrefMethodInfo ResolveTlsClientConnectionMethod "watchClosure" o = GObject.Object.ObjectWatchClosureMethodInfo ResolveTlsClientConnectionMethod "getAcceptedCas" o = TlsClientConnectionGetAcceptedCasMethodInfo ResolveTlsClientConnectionMethod "getCertificate" o = Gio.TlsConnection.TlsConnectionGetCertificateMethodInfo ResolveTlsClientConnectionMethod "getData" o = GObject.Object.ObjectGetDataMethodInfo ResolveTlsClientConnectionMethod "getDatabase" o = Gio.TlsConnection.TlsConnectionGetDatabaseMethodInfo ResolveTlsClientConnectionMethod "getInputStream" o = Gio.IOStream.IOStreamGetInputStreamMethodInfo ResolveTlsClientConnectionMethod "getInteraction" o = Gio.TlsConnection.TlsConnectionGetInteractionMethodInfo ResolveTlsClientConnectionMethod "getNegotiatedProtocol" o = Gio.TlsConnection.TlsConnectionGetNegotiatedProtocolMethodInfo ResolveTlsClientConnectionMethod "getOutputStream" o = Gio.IOStream.IOStreamGetOutputStreamMethodInfo ResolveTlsClientConnectionMethod "getPeerCertificate" o = Gio.TlsConnection.TlsConnectionGetPeerCertificateMethodInfo ResolveTlsClientConnectionMethod "getPeerCertificateErrors" o = Gio.TlsConnection.TlsConnectionGetPeerCertificateErrorsMethodInfo ResolveTlsClientConnectionMethod "getProperty" o = GObject.Object.ObjectGetPropertyMethodInfo ResolveTlsClientConnectionMethod "getQdata" o = GObject.Object.ObjectGetQdataMethodInfo ResolveTlsClientConnectionMethod "getRehandshakeMode" o = Gio.TlsConnection.TlsConnectionGetRehandshakeModeMethodInfo ResolveTlsClientConnectionMethod "getRequireCloseNotify" o = Gio.TlsConnection.TlsConnectionGetRequireCloseNotifyMethodInfo ResolveTlsClientConnectionMethod "getServerIdentity" o = TlsClientConnectionGetServerIdentityMethodInfo ResolveTlsClientConnectionMethod "getUseSsl3" o = TlsClientConnectionGetUseSsl3MethodInfo ResolveTlsClientConnectionMethod "getUseSystemCertdb" o = Gio.TlsConnection.TlsConnectionGetUseSystemCertdbMethodInfo ResolveTlsClientConnectionMethod "getValidationFlags" o = TlsClientConnectionGetValidationFlagsMethodInfo ResolveTlsClientConnectionMethod "setAdvertisedProtocols" o = Gio.TlsConnection.TlsConnectionSetAdvertisedProtocolsMethodInfo ResolveTlsClientConnectionMethod "setCertificate" o = Gio.TlsConnection.TlsConnectionSetCertificateMethodInfo ResolveTlsClientConnectionMethod "setData" o = GObject.Object.ObjectSetDataMethodInfo ResolveTlsClientConnectionMethod "setDatabase" o = Gio.TlsConnection.TlsConnectionSetDatabaseMethodInfo ResolveTlsClientConnectionMethod "setInteraction" o = Gio.TlsConnection.TlsConnectionSetInteractionMethodInfo ResolveTlsClientConnectionMethod "setPending" o = Gio.IOStream.IOStreamSetPendingMethodInfo ResolveTlsClientConnectionMethod "setProperty" o = GObject.Object.ObjectSetPropertyMethodInfo ResolveTlsClientConnectionMethod "setRehandshakeMode" o = Gio.TlsConnection.TlsConnectionSetRehandshakeModeMethodInfo ResolveTlsClientConnectionMethod "setRequireCloseNotify" o = Gio.TlsConnection.TlsConnectionSetRequireCloseNotifyMethodInfo ResolveTlsClientConnectionMethod "setServerIdentity" o = TlsClientConnectionSetServerIdentityMethodInfo ResolveTlsClientConnectionMethod "setUseSsl3" o = TlsClientConnectionSetUseSsl3MethodInfo ResolveTlsClientConnectionMethod "setUseSystemCertdb" o = Gio.TlsConnection.TlsConnectionSetUseSystemCertdbMethodInfo ResolveTlsClientConnectionMethod "setValidationFlags" o = TlsClientConnectionSetValidationFlagsMethodInfo ResolveTlsClientConnectionMethod l o = O.MethodResolutionFailed l o instance (info ~ ResolveTlsClientConnectionMethod t TlsClientConnection, O.MethodInfo info TlsClientConnection p) => OL.IsLabel t (TlsClientConnection -> p) where #if MIN_VERSION_base(4,10,0) fromLabel = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #else fromLabel _ = O.overloadedMethod (O.MethodProxy :: O.MethodProxy info) #endif #endif -- method TlsClientConnection::copy_session_state -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsClientConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "source", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GTlsClientConnection", 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_client_connection_copy_session_state" g_tls_client_connection_copy_session_state :: Ptr TlsClientConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) Ptr TlsClientConnection -> -- source : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) IO () {- | Copies session state from one connection to another. This is not normally needed, but may be used when the same session needs to be used between different endpoints as is required by some protocols such as FTP over TLS. /@source@/ should have already completed a handshake, and /@conn@/ should not have completed a handshake. /Since: 2.46/ -} tlsClientConnectionCopySessionState :: (B.CallStack.HasCallStack, MonadIO m, IsTlsClientConnection a, IsTlsClientConnection b) => a {- ^ /@conn@/: a 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> b {- ^ /@source@/: a 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> m () tlsClientConnectionCopySessionState conn source = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn source' <- unsafeManagedPtrCastPtr source g_tls_client_connection_copy_session_state conn' source' touchManagedPtr conn touchManagedPtr source return () #if ENABLE_OVERLOADING data TlsClientConnectionCopySessionStateMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsTlsClientConnection a, IsTlsClientConnection b) => O.MethodInfo TlsClientConnectionCopySessionStateMethodInfo a signature where overloadedMethod _ = tlsClientConnectionCopySessionState #endif -- method TlsClientConnection::get_accepted_cas -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTlsClientConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TGList TByteArray) -- throws : False -- Skip return : False foreign import ccall "g_tls_client_connection_get_accepted_cas" g_tls_client_connection_get_accepted_cas :: Ptr TlsClientConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) IO (Ptr (GList (Ptr GByteArray))) {- | Gets the list of distinguished names of the Certificate Authorities that the server will accept certificates from. This will be set during the TLS handshake if the server requests a certificate. Otherwise, it will be 'Nothing'. Each item in the list is a 'GI.GLib.Structs.ByteArray.ByteArray' which contains the complete subject DN of the certificate authority. /Since: 2.28/ -} tlsClientConnectionGetAcceptedCas :: (B.CallStack.HasCallStack, MonadIO m, IsTlsClientConnection a) => a {- ^ /@conn@/: the 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> m [ByteString] {- ^ __Returns:__ the list of CA DNs. You should unref each element with 'GI.GLib.Functions.byteArrayUnref' and then the free the list with @/g_list_free()/@. -} tlsClientConnectionGetAcceptedCas conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_client_connection_get_accepted_cas conn' result' <- unpackGList result result'' <- mapM unpackGByteArray result' mapGList unrefGByteArray result g_list_free result touchManagedPtr conn return result'' #if ENABLE_OVERLOADING data TlsClientConnectionGetAcceptedCasMethodInfo instance (signature ~ (m [ByteString]), MonadIO m, IsTlsClientConnection a) => O.MethodInfo TlsClientConnectionGetAcceptedCasMethodInfo a signature where overloadedMethod _ = tlsClientConnectionGetAcceptedCas #endif -- method TlsClientConnection::get_server_identity -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTlsClientConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "SocketConnectable"})) -- throws : False -- Skip return : False foreign import ccall "g_tls_client_connection_get_server_identity" g_tls_client_connection_get_server_identity :: Ptr TlsClientConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) IO (Ptr Gio.SocketConnectable.SocketConnectable) {- | Gets /@conn@/\'s expected server identity /Since: 2.28/ -} tlsClientConnectionGetServerIdentity :: (B.CallStack.HasCallStack, MonadIO m, IsTlsClientConnection a) => a {- ^ /@conn@/: the 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> m Gio.SocketConnectable.SocketConnectable {- ^ __Returns:__ a 'GI.Gio.Interfaces.SocketConnectable.SocketConnectable' describing the expected server identity, or 'Nothing' if the expected identity is not known. -} tlsClientConnectionGetServerIdentity conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_client_connection_get_server_identity conn' checkUnexpectedReturnNULL "tlsClientConnectionGetServerIdentity" result result' <- (newObject Gio.SocketConnectable.SocketConnectable) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsClientConnectionGetServerIdentityMethodInfo instance (signature ~ (m Gio.SocketConnectable.SocketConnectable), MonadIO m, IsTlsClientConnection a) => O.MethodInfo TlsClientConnectionGetServerIdentityMethodInfo a signature where overloadedMethod _ = tlsClientConnectionGetServerIdentity #endif -- method TlsClientConnection::get_use_ssl3 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTlsClientConnection", 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_client_connection_get_use_ssl3" g_tls_client_connection_get_use_ssl3 :: Ptr TlsClientConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) IO CInt {-# DEPRECATED tlsClientConnectionGetUseSsl3 ["(Since version 2.56)","SSL 3.0 is insecure, and this function does not","actually indicate whether it is enabled."] #-} {- | Gets whether /@conn@/ will force the lowest-supported TLS protocol version rather than attempt to negotiate the highest mutually- supported version of TLS; see 'GI.Gio.Interfaces.TlsClientConnection.tlsClientConnectionSetUseSsl3'. /Since: 2.28/ -} tlsClientConnectionGetUseSsl3 :: (B.CallStack.HasCallStack, MonadIO m, IsTlsClientConnection a) => a {- ^ /@conn@/: the 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> m Bool {- ^ __Returns:__ whether /@conn@/ will use the lowest-supported TLS protocol version -} tlsClientConnectionGetUseSsl3 conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_client_connection_get_use_ssl3 conn' let result' = (/= 0) result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsClientConnectionGetUseSsl3MethodInfo instance (signature ~ (m Bool), MonadIO m, IsTlsClientConnection a) => O.MethodInfo TlsClientConnectionGetUseSsl3MethodInfo a signature where overloadedMethod _ = tlsClientConnectionGetUseSsl3 #endif -- method TlsClientConnection::get_validation_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTlsClientConnection", 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_client_connection_get_validation_flags" g_tls_client_connection_get_validation_flags :: Ptr TlsClientConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) IO CUInt {- | Gets /@conn@/\'s validation flags /Since: 2.28/ -} tlsClientConnectionGetValidationFlags :: (B.CallStack.HasCallStack, MonadIO m, IsTlsClientConnection a) => a {- ^ /@conn@/: the 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> m [Gio.Flags.TlsCertificateFlags] {- ^ __Returns:__ the validation flags -} tlsClientConnectionGetValidationFlags conn = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn result <- g_tls_client_connection_get_validation_flags conn' let result' = wordToGFlags result touchManagedPtr conn return result' #if ENABLE_OVERLOADING data TlsClientConnectionGetValidationFlagsMethodInfo instance (signature ~ (m [Gio.Flags.TlsCertificateFlags]), MonadIO m, IsTlsClientConnection a) => O.MethodInfo TlsClientConnectionGetValidationFlagsMethodInfo a signature where overloadedMethod _ = tlsClientConnectionGetValidationFlags #endif -- method TlsClientConnection::set_server_identity -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTlsClientConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "identity", argType = TInterface (Name {namespace = "Gio", name = "SocketConnectable"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "a #GSocketConnectable describing the expected server identity", 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_client_connection_set_server_identity" g_tls_client_connection_set_server_identity :: Ptr TlsClientConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) Ptr Gio.SocketConnectable.SocketConnectable -> -- identity : TInterface (Name {namespace = "Gio", name = "SocketConnectable"}) IO () {- | Sets /@conn@/\'s expected server identity, which is used both to tell servers on virtual hosts which certificate to present, and also to let /@conn@/ know what name to look for in the certificate when performing 'GI.Gio.Flags.TlsCertificateFlagsBadIdentity' validation, if enabled. /Since: 2.28/ -} tlsClientConnectionSetServerIdentity :: (B.CallStack.HasCallStack, MonadIO m, IsTlsClientConnection a, Gio.SocketConnectable.IsSocketConnectable b) => a {- ^ /@conn@/: the 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> b {- ^ /@identity@/: a 'GI.Gio.Interfaces.SocketConnectable.SocketConnectable' describing the expected server identity -} -> m () tlsClientConnectionSetServerIdentity conn identity = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn identity' <- unsafeManagedPtrCastPtr identity g_tls_client_connection_set_server_identity conn' identity' touchManagedPtr conn touchManagedPtr identity return () #if ENABLE_OVERLOADING data TlsClientConnectionSetServerIdentityMethodInfo instance (signature ~ (b -> m ()), MonadIO m, IsTlsClientConnection a, Gio.SocketConnectable.IsSocketConnectable b) => O.MethodInfo TlsClientConnectionSetServerIdentityMethodInfo a signature where overloadedMethod _ = tlsClientConnectionSetServerIdentity #endif -- method TlsClientConnection::set_use_ssl3 -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTlsClientConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "use_ssl3", argType = TBasicType TBoolean, direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "whether to use the lowest-supported protocol version", 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_client_connection_set_use_ssl3" g_tls_client_connection_set_use_ssl3 :: Ptr TlsClientConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) CInt -> -- use_ssl3 : TBasicType TBoolean IO () {-# DEPRECATED tlsClientConnectionSetUseSsl3 ["(Since version 2.56)","SSL 3.0 is insecure, and this function does not","generally enable or disable it, despite its name."] #-} {- | Since 2.42.1, if /@useSsl3@/ is 'True', this forces /@conn@/ to use the lowest-supported TLS protocol version rather than trying to properly negotiate the highest mutually-supported protocol version with the peer. Be aware that SSL 3.0 is generally disabled by the 'GI.Gio.Interfaces.TlsBackend.TlsBackend', so the lowest-supported protocol version is probably not SSL 3.0. Since 2.58, this may additionally cause an RFC 7507 fallback SCSV to be sent to the server, causing modern TLS servers to immediately terminate the connection. You should generally only use this function if you need to connect to broken servers that exhibit TLS protocol version intolerance, and when an initial attempt to connect to a server normally has already failed. /Since: 2.28/ -} tlsClientConnectionSetUseSsl3 :: (B.CallStack.HasCallStack, MonadIO m, IsTlsClientConnection a) => a {- ^ /@conn@/: the 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> Bool {- ^ /@useSsl3@/: whether to use the lowest-supported protocol version -} -> m () tlsClientConnectionSetUseSsl3 conn useSsl3 = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn let useSsl3' = (fromIntegral . fromEnum) useSsl3 g_tls_client_connection_set_use_ssl3 conn' useSsl3' touchManagedPtr conn return () #if ENABLE_OVERLOADING data TlsClientConnectionSetUseSsl3MethodInfo instance (signature ~ (Bool -> m ()), MonadIO m, IsTlsClientConnection a) => O.MethodInfo TlsClientConnectionSetUseSsl3MethodInfo a signature where overloadedMethod _ = tlsClientConnectionSetUseSsl3 #endif -- method TlsClientConnection::set_validation_flags -- method type : OrdinaryMethod -- Args : [Arg {argCName = "conn", argType = TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTlsClientConnection", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "flags", argType = TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GTlsCertificateFlags to use", 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_client_connection_set_validation_flags" g_tls_client_connection_set_validation_flags :: Ptr TlsClientConnection -> -- conn : TInterface (Name {namespace = "Gio", name = "TlsClientConnection"}) CUInt -> -- flags : TInterface (Name {namespace = "Gio", name = "TlsCertificateFlags"}) IO () {- | Sets /@conn@/\'s validation flags, to override the default set of checks performed when validating a server certificate. By default, 'GI.Gio.Flags.TlsCertificateFlagsValidateAll' is used. /Since: 2.28/ -} tlsClientConnectionSetValidationFlags :: (B.CallStack.HasCallStack, MonadIO m, IsTlsClientConnection a) => a {- ^ /@conn@/: the 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' -} -> [Gio.Flags.TlsCertificateFlags] {- ^ /@flags@/: the 'GI.Gio.Flags.TlsCertificateFlags' to use -} -> m () tlsClientConnectionSetValidationFlags conn flags = liftIO $ do conn' <- unsafeManagedPtrCastPtr conn let flags' = gflagsToWord flags g_tls_client_connection_set_validation_flags conn' flags' touchManagedPtr conn return () #if ENABLE_OVERLOADING data TlsClientConnectionSetValidationFlagsMethodInfo instance (signature ~ ([Gio.Flags.TlsCertificateFlags] -> m ()), MonadIO m, IsTlsClientConnection a) => O.MethodInfo TlsClientConnectionSetValidationFlagsMethodInfo a signature where overloadedMethod _ = tlsClientConnectionSetValidationFlags #endif -- method TlsClientConnection::new -- method type : MemberFunction -- Args : [Arg {argCName = "base_io_stream", argType = TInterface (Name {namespace = "Gio", name = "IOStream"}), direction = DirectionIn, mayBeNull = False, argDoc = Documentation {rawDocText = Just "the #GIOStream to wrap", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing},Arg {argCName = "server_identity", argType = TInterface (Name {namespace = "Gio", name = "SocketConnectable"}), direction = DirectionIn, mayBeNull = True, argDoc = Documentation {rawDocText = Just "the expected identity of the server", sinceVersion = Nothing}, argScope = ScopeTypeInvalid, argClosure = -1, argDestroy = -1, argCallerAllocates = False, transfer = TransferNothing}] -- Lengths : [] -- returnType : Just (TInterface (Name {namespace = "Gio", name = "TlsClientConnection"})) -- throws : True -- Skip return : False foreign import ccall "g_tls_client_connection_new" g_tls_client_connection_new :: Ptr Gio.IOStream.IOStream -> -- base_io_stream : TInterface (Name {namespace = "Gio", name = "IOStream"}) Ptr Gio.SocketConnectable.SocketConnectable -> -- server_identity : TInterface (Name {namespace = "Gio", name = "SocketConnectable"}) Ptr (Ptr GError) -> -- error IO (Ptr TlsClientConnection) {- | Creates a new 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection' wrapping /@baseIoStream@/ (which must have pollable input and output streams) which is assumed to communicate with the server identified by /@serverIdentity@/. See the documentation for 'GI.Gio.Objects.TlsConnection.TlsConnection':@/base-io-stream/@ for restrictions on when application code can run operations on the /@baseIoStream@/ after this function has returned. /Since: 2.28/ -} tlsClientConnectionNew :: (B.CallStack.HasCallStack, MonadIO m, Gio.IOStream.IsIOStream a, Gio.SocketConnectable.IsSocketConnectable b) => a {- ^ /@baseIoStream@/: the 'GI.Gio.Objects.IOStream.IOStream' to wrap -} -> Maybe (b) {- ^ /@serverIdentity@/: the expected identity of the server -} -> m TlsClientConnection {- ^ __Returns:__ the new 'GI.Gio.Interfaces.TlsClientConnection.TlsClientConnection', or 'Nothing' on error /(Can throw 'Data.GI.Base.GError.GError')/ -} tlsClientConnectionNew baseIoStream serverIdentity = liftIO $ do baseIoStream' <- unsafeManagedPtrCastPtr baseIoStream maybeServerIdentity <- case serverIdentity of Nothing -> return nullPtr Just jServerIdentity -> do jServerIdentity' <- unsafeManagedPtrCastPtr jServerIdentity return jServerIdentity' onException (do result <- propagateGError $ g_tls_client_connection_new baseIoStream' maybeServerIdentity checkUnexpectedReturnNULL "tlsClientConnectionNew" result result' <- (wrapObject TlsClientConnection) result touchManagedPtr baseIoStream whenJust serverIdentity touchManagedPtr return result' ) (do return () ) #if ENABLE_OVERLOADING #endif