| Copyright | Will Thompson, Iñaki García Etxebarria and Jonas Platte |
|---|---|
| License | LGPL-2.1 |
| Maintainer | Iñaki García Etxebarria (garetxe@gmail.com) |
| Safe Haskell | None |
| Language | Haskell2010 |
GI.Soup.Objects.Session
Contents
- Exported types
- Methods
- abort
- addFeature
- addFeatureByType
- cancelMessage
- getAsyncContext
- getFeature
- getFeatureForMessage
- getFeatures
- hasFeature
- new
- pauseMessage
- prefetchDns
- prepareForUri
- queueMessage
- redirectMessage
- removeFeature
- removeFeatureByType
- request
- requestHttp
- requestHttpUri
- requestUri
- requeueMessage
- send
- sendAsync
- sendFinish
- sendMessage
- stealConnection
- unpauseMessage
- websocketConnectAsync
- websocketConnectFinish
- wouldRedirect
- Properties
- Signals
Description
- newtype Session = Session (ManagedPtr Session)
- class GObject o => IsSession o
- toSession :: IsSession o => o -> IO Session
- noSession :: Maybe Session
- data SessionAbortMethodInfo
- sessionAbort :: (HasCallStack, MonadIO m, IsSession a) => a -> m ()
- data SessionAddFeatureMethodInfo
- sessionAddFeature :: (HasCallStack, MonadIO m, IsSession a, IsSessionFeature b) => a -> b -> m ()
- data SessionAddFeatureByTypeMethodInfo
- sessionAddFeatureByType :: (HasCallStack, MonadIO m, IsSession a) => a -> GType -> m ()
- data SessionCancelMessageMethodInfo
- sessionCancelMessage :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> Word32 -> m ()
- data SessionGetAsyncContextMethodInfo
- sessionGetAsyncContext :: (HasCallStack, MonadIO m, IsSession a) => a -> m (Maybe MainContext)
- data SessionGetFeatureMethodInfo
- sessionGetFeature :: (HasCallStack, MonadIO m, IsSession a) => a -> GType -> m (Maybe SessionFeature)
- data SessionGetFeatureForMessageMethodInfo
- sessionGetFeatureForMessage :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> GType -> b -> m (Maybe SessionFeature)
- data SessionGetFeaturesMethodInfo
- sessionGetFeatures :: (HasCallStack, MonadIO m, IsSession a) => a -> GType -> m [SessionFeature]
- data SessionHasFeatureMethodInfo
- sessionHasFeature :: (HasCallStack, MonadIO m, IsSession a) => a -> GType -> m Bool
- sessionNew :: (HasCallStack, MonadIO m) => m Session
- data SessionPauseMessageMethodInfo
- sessionPauseMessage :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> m ()
- data SessionPrefetchDnsMethodInfo
- sessionPrefetchDns :: (HasCallStack, MonadIO m, IsSession a, IsCancellable b) => a -> Text -> Maybe b -> Maybe AddressCallback -> m ()
- data SessionPrepareForUriMethodInfo
- sessionPrepareForUri :: (HasCallStack, MonadIO m, IsSession a) => a -> URI -> m ()
- data SessionQueueMessageMethodInfo
- sessionQueueMessage :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> Maybe SessionCallback -> m ()
- data SessionRedirectMessageMethodInfo
- sessionRedirectMessage :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> m Bool
- data SessionRemoveFeatureMethodInfo
- sessionRemoveFeature :: (HasCallStack, MonadIO m, IsSession a, IsSessionFeature b) => a -> b -> m ()
- data SessionRemoveFeatureByTypeMethodInfo
- sessionRemoveFeatureByType :: (HasCallStack, MonadIO m, IsSession a) => a -> GType -> m ()
- data SessionRequestMethodInfo
- sessionRequest :: (HasCallStack, MonadIO m, IsSession a) => a -> Text -> m Request
- data SessionRequestHttpMethodInfo
- sessionRequestHttp :: (HasCallStack, MonadIO m, IsSession a) => a -> Text -> Text -> m RequestHTTP
- data SessionRequestHttpUriMethodInfo
- sessionRequestHttpUri :: (HasCallStack, MonadIO m, IsSession a) => a -> Text -> URI -> m RequestHTTP
- data SessionRequestUriMethodInfo
- sessionRequestUri :: (HasCallStack, MonadIO m, IsSession a) => a -> URI -> m Request
- data SessionRequeueMessageMethodInfo
- sessionRequeueMessage :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> m ()
- data SessionSendMethodInfo
- sessionSend :: (HasCallStack, MonadIO m, IsSession a, IsMessage b, IsCancellable c) => a -> b -> Maybe c -> m InputStream
- data SessionSendAsyncMethodInfo
- sessionSendAsync :: (HasCallStack, MonadIO m, IsSession a, IsMessage b, IsCancellable c) => a -> b -> Maybe c -> Maybe AsyncReadyCallback -> m ()
- data SessionSendFinishMethodInfo
- sessionSendFinish :: (HasCallStack, MonadIO m, IsSession a, IsAsyncResult b) => a -> b -> m InputStream
- data SessionSendMessageMethodInfo
- sessionSendMessage :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> m Word32
- data SessionStealConnectionMethodInfo
- sessionStealConnection :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> m IOStream
- data SessionUnpauseMessageMethodInfo
- sessionUnpauseMessage :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> m ()
- data SessionWebsocketConnectAsyncMethodInfo
- sessionWebsocketConnectAsync :: (HasCallStack, MonadIO m, IsSession a, IsMessage b, IsCancellable c) => a -> b -> Maybe Text -> Maybe [Text] -> Maybe c -> Maybe AsyncReadyCallback -> m ()
- data SessionWebsocketConnectFinishMethodInfo
- sessionWebsocketConnectFinish :: (HasCallStack, MonadIO m, IsSession a, IsAsyncResult b) => a -> b -> m WebsocketConnection
- data SessionWouldRedirectMethodInfo
- sessionWouldRedirect :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) => a -> b -> m Bool
- data SessionAcceptLanguagePropertyInfo
- clearSessionAcceptLanguage :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionAcceptLanguage :: IsSession o => Text -> IO (GValueConstruct o)
- getSessionAcceptLanguage :: (MonadIO m, IsSession o) => o -> m (Maybe Text)
- sessionAcceptLanguage :: AttrLabelProxy "acceptLanguage"
- setSessionAcceptLanguage :: (MonadIO m, IsSession o) => o -> Text -> m ()
- data SessionAcceptLanguageAutoPropertyInfo
- constructSessionAcceptLanguageAuto :: IsSession o => Bool -> IO (GValueConstruct o)
- getSessionAcceptLanguageAuto :: (MonadIO m, IsSession o) => o -> m Bool
- sessionAcceptLanguageAuto :: AttrLabelProxy "acceptLanguageAuto"
- setSessionAcceptLanguageAuto :: (MonadIO m, IsSession o) => o -> Bool -> m ()
- data SessionAsyncContextPropertyInfo
- constructSessionAsyncContext :: IsSession o => Ptr () -> IO (GValueConstruct o)
- getSessionAsyncContext :: (MonadIO m, IsSession o) => o -> m (Ptr ())
- sessionAsyncContext :: AttrLabelProxy "asyncContext"
- data SessionHttpAliasesPropertyInfo
- clearSessionHttpAliases :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionHttpAliases :: IsSession o => [Text] -> IO (GValueConstruct o)
- getSessionHttpAliases :: (MonadIO m, IsSession o) => o -> m (Maybe [Text])
- sessionHttpAliases :: AttrLabelProxy "httpAliases"
- setSessionHttpAliases :: (MonadIO m, IsSession o) => o -> [Text] -> m ()
- data SessionHttpsAliasesPropertyInfo
- clearSessionHttpsAliases :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionHttpsAliases :: IsSession o => [Text] -> IO (GValueConstruct o)
- getSessionHttpsAliases :: (MonadIO m, IsSession o) => o -> m (Maybe [Text])
- sessionHttpsAliases :: AttrLabelProxy "httpsAliases"
- setSessionHttpsAliases :: (MonadIO m, IsSession o) => o -> [Text] -> m ()
- data SessionIdleTimeoutPropertyInfo
- constructSessionIdleTimeout :: IsSession o => Word32 -> IO (GValueConstruct o)
- getSessionIdleTimeout :: (MonadIO m, IsSession o) => o -> m Word32
- sessionIdleTimeout :: AttrLabelProxy "idleTimeout"
- setSessionIdleTimeout :: (MonadIO m, IsSession o) => o -> Word32 -> m ()
- data SessionLocalAddressPropertyInfo
- constructSessionLocalAddress :: (IsSession o, IsAddress a) => a -> IO (GValueConstruct o)
- getSessionLocalAddress :: (MonadIO m, IsSession o) => o -> m (Maybe Address)
- sessionLocalAddress :: AttrLabelProxy "localAddress"
- data SessionMaxConnsPropertyInfo
- constructSessionMaxConns :: IsSession o => Int32 -> IO (GValueConstruct o)
- getSessionMaxConns :: (MonadIO m, IsSession o) => o -> m Int32
- sessionMaxConns :: AttrLabelProxy "maxConns"
- setSessionMaxConns :: (MonadIO m, IsSession o) => o -> Int32 -> m ()
- data SessionMaxConnsPerHostPropertyInfo
- constructSessionMaxConnsPerHost :: IsSession o => Int32 -> IO (GValueConstruct o)
- getSessionMaxConnsPerHost :: (MonadIO m, IsSession o) => o -> m Int32
- sessionMaxConnsPerHost :: AttrLabelProxy "maxConnsPerHost"
- setSessionMaxConnsPerHost :: (MonadIO m, IsSession o) => o -> Int32 -> m ()
- data SessionProxyResolverPropertyInfo
- clearSessionProxyResolver :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionProxyResolver :: (IsSession o, IsProxyResolver a) => a -> IO (GValueConstruct o)
- getSessionProxyResolver :: (MonadIO m, IsSession o) => o -> m (Maybe ProxyResolver)
- sessionProxyResolver :: AttrLabelProxy "proxyResolver"
- setSessionProxyResolver :: (MonadIO m, IsSession o, IsProxyResolver a) => o -> a -> m ()
- data SessionProxyUriPropertyInfo
- clearSessionProxyUri :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionProxyUri :: IsSession o => URI -> IO (GValueConstruct o)
- getSessionProxyUri :: (MonadIO m, IsSession o) => o -> m (Maybe URI)
- sessionProxyUri :: AttrLabelProxy "proxyUri"
- setSessionProxyUri :: (MonadIO m, IsSession o) => o -> URI -> m ()
- data SessionSslCaFilePropertyInfo
- clearSessionSslCaFile :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionSslCaFile :: IsSession o => Text -> IO (GValueConstruct o)
- getSessionSslCaFile :: (MonadIO m, IsSession o) => o -> m (Maybe Text)
- sessionSslCaFile :: AttrLabelProxy "sslCaFile"
- setSessionSslCaFile :: (MonadIO m, IsSession o) => o -> Text -> m ()
- data SessionSslStrictPropertyInfo
- constructSessionSslStrict :: IsSession o => Bool -> IO (GValueConstruct o)
- getSessionSslStrict :: (MonadIO m, IsSession o) => o -> m Bool
- sessionSslStrict :: AttrLabelProxy "sslStrict"
- setSessionSslStrict :: (MonadIO m, IsSession o) => o -> Bool -> m ()
- data SessionSslUseSystemCaFilePropertyInfo
- constructSessionSslUseSystemCaFile :: IsSession o => Bool -> IO (GValueConstruct o)
- getSessionSslUseSystemCaFile :: (MonadIO m, IsSession o) => o -> m Bool
- sessionSslUseSystemCaFile :: AttrLabelProxy "sslUseSystemCaFile"
- setSessionSslUseSystemCaFile :: (MonadIO m, IsSession o) => o -> Bool -> m ()
- data SessionTimeoutPropertyInfo
- constructSessionTimeout :: IsSession o => Word32 -> IO (GValueConstruct o)
- getSessionTimeout :: (MonadIO m, IsSession o) => o -> m Word32
- sessionTimeout :: AttrLabelProxy "timeout"
- setSessionTimeout :: (MonadIO m, IsSession o) => o -> Word32 -> m ()
- data SessionTlsDatabasePropertyInfo
- clearSessionTlsDatabase :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionTlsDatabase :: (IsSession o, IsTlsDatabase a) => a -> IO (GValueConstruct o)
- getSessionTlsDatabase :: (MonadIO m, IsSession o) => o -> m (Maybe TlsDatabase)
- sessionTlsDatabase :: AttrLabelProxy "tlsDatabase"
- setSessionTlsDatabase :: (MonadIO m, IsSession o, IsTlsDatabase a) => o -> a -> m ()
- data SessionTlsInteractionPropertyInfo
- clearSessionTlsInteraction :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionTlsInteraction :: (IsSession o, IsTlsInteraction a) => a -> IO (GValueConstruct o)
- getSessionTlsInteraction :: (MonadIO m, IsSession o) => o -> m (Maybe TlsInteraction)
- sessionTlsInteraction :: AttrLabelProxy "tlsInteraction"
- setSessionTlsInteraction :: (MonadIO m, IsSession o, IsTlsInteraction a) => o -> a -> m ()
- data SessionUseNtlmPropertyInfo
- constructSessionUseNtlm :: IsSession o => Bool -> IO (GValueConstruct o)
- getSessionUseNtlm :: (MonadIO m, IsSession o) => o -> m Bool
- sessionUseNtlm :: AttrLabelProxy "useNtlm"
- setSessionUseNtlm :: (MonadIO m, IsSession o) => o -> Bool -> m ()
- data SessionUseThreadContextPropertyInfo
- constructSessionUseThreadContext :: IsSession o => Bool -> IO (GValueConstruct o)
- getSessionUseThreadContext :: (MonadIO m, IsSession o) => o -> m Bool
- sessionUseThreadContext :: AttrLabelProxy "useThreadContext"
- setSessionUseThreadContext :: (MonadIO m, IsSession o) => o -> Bool -> m ()
- data SessionUserAgentPropertyInfo
- clearSessionUserAgent :: (MonadIO m, IsSession o) => o -> m ()
- constructSessionUserAgent :: IsSession o => Text -> IO (GValueConstruct o)
- getSessionUserAgent :: (MonadIO m, IsSession o) => o -> m (Maybe Text)
- sessionUserAgent :: AttrLabelProxy "userAgent"
- setSessionUserAgent :: (MonadIO m, IsSession o) => o -> Text -> m ()
- type C_SessionAuthenticateCallback = Ptr () -> Ptr Message -> Ptr Auth -> CInt -> Ptr () -> IO ()
- type SessionAuthenticateCallback = Message -> Auth -> Bool -> IO ()
- data SessionAuthenticateSignalInfo
- afterSessionAuthenticate :: (GObject a, MonadIO m) => a -> SessionAuthenticateCallback -> m SignalHandlerId
- genClosure_SessionAuthenticate :: SessionAuthenticateCallback -> IO Closure
- mk_SessionAuthenticateCallback :: C_SessionAuthenticateCallback -> IO (FunPtr C_SessionAuthenticateCallback)
- noSessionAuthenticateCallback :: Maybe SessionAuthenticateCallback
- onSessionAuthenticate :: (GObject a, MonadIO m) => a -> SessionAuthenticateCallback -> m SignalHandlerId
- wrap_SessionAuthenticateCallback :: SessionAuthenticateCallback -> Ptr () -> Ptr Message -> Ptr Auth -> CInt -> Ptr () -> IO ()
- type C_SessionConnectionCreatedCallback = Ptr () -> Ptr Object -> Ptr () -> IO ()
- type SessionConnectionCreatedCallback = Object -> IO ()
- data SessionConnectionCreatedSignalInfo
- afterSessionConnectionCreated :: (GObject a, MonadIO m) => a -> SessionConnectionCreatedCallback -> m SignalHandlerId
- genClosure_SessionConnectionCreated :: SessionConnectionCreatedCallback -> IO Closure
- mk_SessionConnectionCreatedCallback :: C_SessionConnectionCreatedCallback -> IO (FunPtr C_SessionConnectionCreatedCallback)
- noSessionConnectionCreatedCallback :: Maybe SessionConnectionCreatedCallback
- onSessionConnectionCreated :: (GObject a, MonadIO m) => a -> SessionConnectionCreatedCallback -> m SignalHandlerId
- wrap_SessionConnectionCreatedCallback :: SessionConnectionCreatedCallback -> Ptr () -> Ptr Object -> Ptr () -> IO ()
- type C_SessionRequestQueuedCallback = Ptr () -> Ptr Message -> Ptr () -> IO ()
- type SessionRequestQueuedCallback = Message -> IO ()
- data SessionRequestQueuedSignalInfo
- afterSessionRequestQueued :: (GObject a, MonadIO m) => a -> SessionRequestQueuedCallback -> m SignalHandlerId
- genClosure_SessionRequestQueued :: SessionRequestQueuedCallback -> IO Closure
- mk_SessionRequestQueuedCallback :: C_SessionRequestQueuedCallback -> IO (FunPtr C_SessionRequestQueuedCallback)
- noSessionRequestQueuedCallback :: Maybe SessionRequestQueuedCallback
- onSessionRequestQueued :: (GObject a, MonadIO m) => a -> SessionRequestQueuedCallback -> m SignalHandlerId
- wrap_SessionRequestQueuedCallback :: SessionRequestQueuedCallback -> Ptr () -> Ptr Message -> Ptr () -> IO ()
- type C_SessionRequestStartedCallback = Ptr () -> Ptr Message -> Ptr Socket -> Ptr () -> IO ()
- type SessionRequestStartedCallback = Message -> Socket -> IO ()
- data SessionRequestStartedSignalInfo
- afterSessionRequestStarted :: (GObject a, MonadIO m) => a -> SessionRequestStartedCallback -> m SignalHandlerId
- genClosure_SessionRequestStarted :: SessionRequestStartedCallback -> IO Closure
- mk_SessionRequestStartedCallback :: C_SessionRequestStartedCallback -> IO (FunPtr C_SessionRequestStartedCallback)
- noSessionRequestStartedCallback :: Maybe SessionRequestStartedCallback
- onSessionRequestStarted :: (GObject a, MonadIO m) => a -> SessionRequestStartedCallback -> m SignalHandlerId
- wrap_SessionRequestStartedCallback :: SessionRequestStartedCallback -> Ptr () -> Ptr Message -> Ptr Socket -> Ptr () -> IO ()
- type C_SessionRequestUnqueuedCallback = Ptr () -> Ptr Message -> Ptr () -> IO ()
- type SessionRequestUnqueuedCallback = Message -> IO ()
- data SessionRequestUnqueuedSignalInfo
- afterSessionRequestUnqueued :: (GObject a, MonadIO m) => a -> SessionRequestUnqueuedCallback -> m SignalHandlerId
- genClosure_SessionRequestUnqueued :: SessionRequestUnqueuedCallback -> IO Closure
- mk_SessionRequestUnqueuedCallback :: C_SessionRequestUnqueuedCallback -> IO (FunPtr C_SessionRequestUnqueuedCallback)
- noSessionRequestUnqueuedCallback :: Maybe SessionRequestUnqueuedCallback
- onSessionRequestUnqueued :: (GObject a, MonadIO m) => a -> SessionRequestUnqueuedCallback -> m SignalHandlerId
- wrap_SessionRequestUnqueuedCallback :: SessionRequestUnqueuedCallback -> Ptr () -> Ptr Message -> Ptr () -> IO ()
- type C_SessionTunnelingCallback = Ptr () -> Ptr Object -> Ptr () -> IO ()
- type SessionTunnelingCallback = Object -> IO ()
- data SessionTunnelingSignalInfo
- afterSessionTunneling :: (GObject a, MonadIO m) => a -> SessionTunnelingCallback -> m SignalHandlerId
- genClosure_SessionTunneling :: SessionTunnelingCallback -> IO Closure
- mk_SessionTunnelingCallback :: C_SessionTunnelingCallback -> IO (FunPtr C_SessionTunnelingCallback)
- noSessionTunnelingCallback :: Maybe SessionTunnelingCallback
- onSessionTunneling :: (GObject a, MonadIO m) => a -> SessionTunnelingCallback -> m SignalHandlerId
- wrap_SessionTunnelingCallback :: SessionTunnelingCallback -> Ptr () -> Ptr Object -> Ptr () -> IO ()
Exported types
Constructors
| Session (ManagedPtr Session) |
Instances
| GObject Session Source # | |
| IsObject Session Source # | |
| IsSession Session Source # | |
| ((~) * info (ResolveSessionMethod t Session), MethodInfo * info Session p) => IsLabel t (Session -> p) Source # | |
| ((~) * info (ResolveSessionMethod t Session), MethodInfo * info Session p) => IsLabelProxy t (Session -> p) Source # | |
| HasAttributeList * Session Source # | |
| type AttributeList Session Source # | |
| type SignalList Session Source # | |
Methods
abort
data SessionAbortMethodInfo Source #
Instances
| ((~) * signature (m ()), MonadIO m, IsSession a) => MethodInfo * SessionAbortMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> m () |
Cancels all pending requests in session and closes all idle
persistent connections.
The message cancellation has the same semantics as with
sessionCancelMessage; asynchronous requests on a
SessionAsync will have their callback called before
sessionAbort returns. Requests on a plain Session will
not.
addFeature
data SessionAddFeatureMethodInfo Source #
Instances
| ((~) * signature (b -> m ()), MonadIO m, IsSession a, IsSessionFeature b) => MethodInfo * SessionAddFeatureMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsSessionFeature b) | |
| => a |
|
| -> b |
|
| -> m () |
Adds feature's functionality to session. You can also add a
feature to the session at construct time by using the
SOUP_SESSION_ADD_FEATURE property.
See the main Session documentation for information on what
features are present in sessions by default.
Since: 2.24
addFeatureByType
data SessionAddFeatureByTypeMethodInfo Source #
Instances
| ((~) * signature (GType -> m ()), MonadIO m, IsSession a) => MethodInfo * SessionAddFeatureByTypeMethodInfo a signature Source # | |
sessionAddFeatureByType Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> GType |
|
| -> m () |
If featureType is the type of a class that implements
SessionFeature, this creates a new feature of that type and
adds it to session as with sessionAddFeature. You can use
this when you don't need to customize the new feature in any way.
If featureType is not a SessionFeature type, this gives each
existing feature on session the chance to accept featureType as
a "subfeature". This can be used to add new Auth or
Request types, for instance.
You can also add a feature to the session at construct time by
using the SOUP_SESSION_ADD_FEATURE_BY_TYPE property.
See the main Session documentation for information on what
features are present in sessions by default.
Since: 2.24
cancelMessage
data SessionCancelMessageMethodInfo Source #
Instances
| ((~) * signature (b -> Word32 -> m ()), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionCancelMessageMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> Word32 |
|
| -> m () |
Causes session to immediately finish processing msg (regardless
of its current state) with a final status_code of statusCode. You
may call this at any time after handing msg off to session; if
session has started sending the request but has not yet received
the complete response, then it will close the request's connection.
Note that with requests that have side effects (eg,
<literal>POST</literal>, <literal>PUT</literal>,
<literal>DELETE</literal>) it is possible that you might cancel the
request after the server acts on it, but before it returns a
response, leaving the remote resource in an unknown state.
If the message is cancelled while its response body is being read,
then the response body in msg will be left partially-filled-in.
The response headers, on the other hand, will always be either
empty or complete.
Beware that with the deprecated SessionAsync, messages queued
with sessionQueueMessage will have their callbacks invoked
before sessionCancelMessage returns. The plain
Session does not have this behavior; cancelling an
asynchronous message will merely queue its callback to be run after
returning to the main loop.
getAsyncContext
data SessionGetAsyncContextMethodInfo Source #
Instances
| ((~) * signature (m (Maybe MainContext)), MonadIO m, IsSession a) => MethodInfo * SessionGetAsyncContextMethodInfo a signature Source # | |
sessionGetAsyncContext Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> m (Maybe MainContext) | Returns: |
Gets session's Session:async-context. This does not add a ref
to the context, so you will need to ref it yourself if you want it
to outlive its session.
For a modern Session, this will always just return the
thread-default MainContext, and so is not especially useful.
getFeature
data SessionGetFeatureMethodInfo Source #
Instances
| ((~) * signature (GType -> m (Maybe SessionFeature)), MonadIO m, IsSession a) => MethodInfo * SessionGetFeatureMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> GType |
|
| -> m (Maybe SessionFeature) | Returns: a |
Gets the first feature in session of type featureType. For
features where there may be more than one feature of a given type,
use sessionGetFeatures.
Since: 2.26
getFeatureForMessage
data SessionGetFeatureForMessageMethodInfo Source #
Instances
| ((~) * signature (GType -> b -> m (Maybe SessionFeature)), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionGetFeatureForMessageMethodInfo a signature Source # | |
sessionGetFeatureForMessage Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> GType |
|
| -> b |
|
| -> m (Maybe SessionFeature) | Returns: a |
Gets the first feature in session of type featureType, provided
that it is not disabled for msg. As with
sessionGetFeature, this should only be used for features
where featureType is only expected to match a single feature. In
particular, if there are two matching features, and the first is
disabled on msg, and the second is not, then this will return
Nothing, not the second feature.
Since: 2.28
getFeatures
data SessionGetFeaturesMethodInfo Source #
Instances
| ((~) * signature (GType -> m [SessionFeature]), MonadIO m, IsSession a) => MethodInfo * SessionGetFeaturesMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> GType |
|
| -> m [SessionFeature] | Returns: a list of features. You must free the list, but not its contents |
Generates a list of session's features of type featureType. (If
you want to see all features, you can pass SOUP_TYPE_SESSION_FEATURE
for featureType.)
Since: 2.26
hasFeature
data SessionHasFeatureMethodInfo Source #
Instances
| ((~) * signature (GType -> m Bool), MonadIO m, IsSession a) => MethodInfo * SessionHasFeatureMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> GType |
|
| -> m Bool |
Tests if session has at a feature of type featureType (which can
be the type of either a SessionFeature, or else a subtype of
some class managed by another feature, such as Auth or
Request).
Since: 2.42
new
Arguments
| :: (HasCallStack, MonadIO m) | |
| => m Session | Returns: the new session. |
Creates a Session with the default options.
Since: 2.42
pauseMessage
data SessionPauseMessageMethodInfo Source #
Instances
| ((~) * signature (b -> m ()), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionPauseMessageMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> m () |
Pauses HTTP I/O on msg. Call sessionUnpauseMessage to
resume I/O.
This may only be called for asynchronous messages (those sent on a
SessionAsync or using sessionQueueMessage).
prefetchDns
data SessionPrefetchDnsMethodInfo Source #
Instances
| ((~) * signature (Text -> Maybe b -> Maybe AddressCallback -> m ()), MonadIO m, IsSession a, IsCancellable b) => MethodInfo * SessionPrefetchDnsMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsCancellable b) | |
| => a |
|
| -> Text |
|
| -> Maybe b |
|
| -> Maybe AddressCallback |
|
| -> m () |
Tells session that an URI from the given hostname may be requested
shortly, and so the session can try to prepare by resolving the
domain name in advance, in order to work more quickly once the URI
is actually requested.
If cancellable is non-Nothing, it can be used to cancel the
resolution. callback will still be invoked in this case, with a
status of StatusCancelled.
Since: 2.38
prepareForUri
data SessionPrepareForUriMethodInfo Source #
Instances
| ((~) * signature (URI -> m ()), MonadIO m, IsSession a) => MethodInfo * SessionPrepareForUriMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> URI |
|
| -> m () |
Deprecated: (Since version 2.38)use sessionPrefetchDns instead
Tells session that uri may be requested shortly, and so the
session can try to prepare (resolving the domain name, obtaining
proxy address, etc.) in order to work more quickly once the URI is
actually requested.
Since: 2.30
queueMessage
data SessionQueueMessageMethodInfo Source #
Instances
| ((~) * signature (b -> Maybe SessionCallback -> m ()), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionQueueMessageMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> Maybe SessionCallback |
|
| -> m () |
Queues the message msg for asynchronously sending the request and
receiving a response in the current thread-default MainContext.
If msg has been processed before, any resources related to the
time it was last sent are freed.
Upon message completion, the callback specified in callback will
be invoked. If after returning from this callback the message has not
been requeued, msg will be unreffed.
(The behavior above applies to a plain Session; if you are
using SessionAsync or SessionSync, then the MainContext
that is used depends on the settings of Session:async-context
and Session:use-thread-context, and for SessionSync, the
message will actually be sent and processed in another thread, with
only the final callback occurring in the indicated MainContext.)
Contrast this method with sessionSendAsync, which also
asynchronously sends a message, but returns before reading the
response body, and allows you to read the response via a
InputStream.
redirectMessage
data SessionRedirectMessageMethodInfo Source #
Instances
| ((~) * signature (b -> m Bool), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionRedirectMessageMethodInfo a signature Source # | |
sessionRedirectMessage Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> m Bool | Returns: |
Updates msg's URI according to its status code and "Location"
header, and requeues it on session. Use this when you have set
MessageFlagsNoRedirect on a message, but have decided to allow a
particular redirection to occur, or if you want to allow a
redirection that Session will not perform automatically (eg,
redirecting a non-safe method such as DELETE).
If msg's status code indicates that it should be retried as a GET
request, then msg will be modified accordingly.
If msg has already been redirected too many times, this will
cause it to fail with StatusTooManyRedirects.
Since: 2.38
removeFeature
data SessionRemoveFeatureMethodInfo Source #
Instances
| ((~) * signature (b -> m ()), MonadIO m, IsSession a, IsSessionFeature b) => MethodInfo * SessionRemoveFeatureMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsSessionFeature b) | |
| => a |
|
| -> b |
|
| -> m () |
Removes feature's functionality from session.
Since: 2.24
removeFeatureByType
data SessionRemoveFeatureByTypeMethodInfo Source #
Instances
| ((~) * signature (GType -> m ()), MonadIO m, IsSession a) => MethodInfo * SessionRemoveFeatureByTypeMethodInfo a signature Source # | |
sessionRemoveFeatureByType Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> GType |
|
| -> m () |
Removes all features of type featureType (or any subclass of
featureType) from session. You can also remove standard features
from the session at construct time by using the
SOUP_SESSION_REMOVE_FEATURE_BY_TYPE property.
Since: 2.24
request
data SessionRequestMethodInfo Source #
Instances
| ((~) * signature (Text -> m Request), MonadIO m, IsSession a) => MethodInfo * SessionRequestMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> Text |
|
| -> m Request | Returns: a new |
Creates a Request for retrieving uriString.
Since: 2.42
requestHttp
data SessionRequestHttpMethodInfo Source #
Instances
| ((~) * signature (Text -> Text -> m RequestHTTP), MonadIO m, IsSession a) => MethodInfo * SessionRequestHttpMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> Text |
|
| -> Text |
|
| -> m RequestHTTP | Returns: a new |
requestHttpUri
data SessionRequestHttpUriMethodInfo Source #
Instances
| ((~) * signature (Text -> URI -> m RequestHTTP), MonadIO m, IsSession a) => MethodInfo * SessionRequestHttpUriMethodInfo a signature Source # | |
sessionRequestHttpUri Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> Text |
|
| -> URI |
|
| -> m RequestHTTP | Returns: a new |
requestUri
data SessionRequestUriMethodInfo Source #
Instances
| ((~) * signature (URI -> m Request), MonadIO m, IsSession a) => MethodInfo * SessionRequestUriMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a) | |
| => a |
|
| -> URI |
|
| -> m Request | Returns: a new |
Creates a Request for retrieving uri.
Since: 2.42
requeueMessage
data SessionRequeueMessageMethodInfo Source #
Instances
| ((~) * signature (b -> m ()), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionRequeueMessageMethodInfo a signature Source # | |
sessionRequeueMessage Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> m () |
This causes msg to be placed back on the queue to be attempted
again.
send
data SessionSendMethodInfo Source #
Instances
| ((~) * signature (b -> Maybe c -> m InputStream), MonadIO m, IsSession a, IsMessage b, IsCancellable c) => MethodInfo * SessionSendMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b, IsCancellable c) | |
| => a |
|
| -> b |
|
| -> Maybe c |
|
| -> m InputStream | Returns: a |
Synchronously sends msg and waits for the beginning of a response.
On success, a InputStream will be returned which you can use to
read the response body. ("Success" here means only that an HTTP
response was received and understood; it does not necessarily mean
that a 2xx class status code was received.)
If non-Nothing, cancellable can be used to cancel the request;
sessionSend will return a IOErrorEnumCancelled error. Note
that with requests that have side effects (eg,
<literal>POST</literal>, <literal>PUT</literal>,
<literal>DELETE</literal>) it is possible that you might cancel the
request after the server acts on it, but before it returns a
response, leaving the remote resource in an unknown state.
If msg is requeued due to a redirect or authentication, the
initial (3xx/401/407) response body will be suppressed, and
sessionSend will only return once a final response has been
received.
Contrast this method with sessionSendMessage, which also
synchronously sends a Message, but doesn't return until the
response has been completely read.
(Note that this method cannot be called on the deprecated
SessionAsync subclass.)
Since: 2.42
sendAsync
data SessionSendAsyncMethodInfo Source #
Instances
| ((~) * signature (b -> Maybe c -> Maybe AsyncReadyCallback -> m ()), MonadIO m, IsSession a, IsMessage b, IsCancellable c) => MethodInfo * SessionSendAsyncMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b, IsCancellable c) | |
| => a |
|
| -> b |
|
| -> Maybe c |
|
| -> Maybe AsyncReadyCallback |
|
| -> m () |
Asynchronously sends msg and waits for the beginning of a
response. When callback is called, then either msg has been sent,
and its response headers received, or else an error has occurred.
Call sessionSendFinish to get a InputStream for reading
the response body.
See sessionSend for more details on the general semantics.
Contrast this method with sessionQueueMessage, which also
asynchronously sends a Message, but doesn't invoke its
callback until the response has been completely read.
(Note that this method cannot be called on the deprecated
SessionSync subclass, and can only be called on
SessionAsync if you have set the
Session:use-thread-context property.)
Since: 2.42
sendFinish
data SessionSendFinishMethodInfo Source #
Instances
| ((~) * signature (b -> m InputStream), MonadIO m, IsSession a, IsAsyncResult b) => MethodInfo * SessionSendFinishMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsAsyncResult b) | |
| => a |
|
| -> b |
|
| -> m InputStream | Returns: a |
Gets the response to a sessionSendAsync call and (if
successful), returns a InputStream that can be used to read the
response body.
Since: 2.42
sendMessage
data SessionSendMessageMethodInfo Source #
Instances
| ((~) * signature (b -> m Word32), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionSendMessageMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> m Word32 | Returns: the HTTP status code of the response |
Synchronously send msg. This call will not return until the
transfer is finished successfully or there is an unrecoverable
error.
Unlike with sessionQueueMessage, msg is not freed upon
return.
(Note that if you call this method on a SessionAsync, it will
still use asynchronous I/O internally, running the glib main loop
to process the message, which may also cause other events to be
processed.)
Contrast this method with sessionSend, which also
synchronously sends a message, but returns before reading the
response body, and allows you to read the response via a
InputStream.
stealConnection
data SessionStealConnectionMethodInfo Source #
Instances
| ((~) * signature (b -> m IOStream), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionStealConnectionMethodInfo a signature Source # | |
sessionStealConnection Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> m IOStream | Returns: the |
"Steals" the HTTP connection associated with msg from session.
This happens immediately, regardless of the current state of the
connection, and msg's callback will not be called. You can steal
the connection from a Message signal handler if you need to
wait for part or all of the response to be received first.
Calling this function may cause msg to be freed if you are not
holding any other reference to it.
Since: 2.50
unpauseMessage
data SessionUnpauseMessageMethodInfo Source #
Instances
| ((~) * signature (b -> m ()), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionUnpauseMessageMethodInfo a signature Source # | |
sessionUnpauseMessage Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> m () |
Resumes HTTP I/O on msg. Use this to resume after calling
sessionPauseMessage.
If msg is being sent via blocking I/O, this will resume reading or
writing immediately. If msg is using non-blocking I/O, then
reading or writing won't resume until you return to the main loop.
This may only be called for asynchronous messages (those sent on a
SessionAsync or using sessionQueueMessage).
websocketConnectAsync
data SessionWebsocketConnectAsyncMethodInfo Source #
Instances
| ((~) * signature (b -> Maybe Text -> Maybe [Text] -> Maybe c -> Maybe AsyncReadyCallback -> m ()), MonadIO m, IsSession a, IsMessage b, IsCancellable c) => MethodInfo * SessionWebsocketConnectAsyncMethodInfo a signature Source # | |
sessionWebsocketConnectAsync Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b, IsCancellable c) | |
| => a |
|
| -> b |
|
| -> Maybe Text |
|
| -> Maybe [Text] |
|
| -> Maybe c |
|
| -> Maybe AsyncReadyCallback |
|
| -> m () |
Asynchronously creates a WebsocketConnection to communicate
with a remote server.
All necessary WebSocket-related headers will be added to msg, and
it will then be sent and asynchronously processed normally
(including handling of redirection and HTTP authentication).
If the server returns "101 Switching Protocols", then msg's status
code and response headers will be updated, and then the WebSocket
handshake will be completed. On success,
soup_websocket_connect_finish() will return a new
WebsocketConnection. On failure it will return a GError.
If the server returns a status other than "101 Switching
Protocols", then msg will contain the complete response headers
and body from the server's response, and
soup_websocket_connect_finish() will return
WebsocketErrorNotWebsocket.
Since: 2.50
websocketConnectFinish
data SessionWebsocketConnectFinishMethodInfo Source #
Instances
| ((~) * signature (b -> m WebsocketConnection), MonadIO m, IsSession a, IsAsyncResult b) => MethodInfo * SessionWebsocketConnectFinishMethodInfo a signature Source # | |
sessionWebsocketConnectFinish Source #
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsAsyncResult b) | |
| => a |
|
| -> b |
|
| -> m WebsocketConnection | Returns: a new |
Gets the WebsocketConnection response to a
sessionWebsocketConnectAsync call and (if successful),
returns a SoupWebsockConnection that can be used to communicate
with the server.
Since: 2.50
wouldRedirect
data SessionWouldRedirectMethodInfo Source #
Instances
| ((~) * signature (b -> m Bool), MonadIO m, IsSession a, IsMessage b) => MethodInfo * SessionWouldRedirectMethodInfo a signature Source # | |
Arguments
| :: (HasCallStack, MonadIO m, IsSession a, IsMessage b) | |
| => a |
|
| -> b |
|
| -> m Bool | Returns: whether |
Checks if msg contains a response that would cause session to
redirect it to a new URL (ignoring msg's MessageFlagsNoRedirect
flag, and the number of times it has already been redirected).
Since: 2.38
Properties
acceptLanguage
data SessionAcceptLanguagePropertyInfo Source #
Instances
clearSessionAcceptLanguage :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionAcceptLanguage :: IsSession o => Text -> IO (GValueConstruct o) Source #
sessionAcceptLanguage :: AttrLabelProxy "acceptLanguage" Source #
acceptLanguageAuto
data SessionAcceptLanguageAutoPropertyInfo Source #
Instances
constructSessionAcceptLanguageAuto :: IsSession o => Bool -> IO (GValueConstruct o) Source #
sessionAcceptLanguageAuto :: AttrLabelProxy "acceptLanguageAuto" Source #
asyncContext
data SessionAsyncContextPropertyInfo Source #
Instances
constructSessionAsyncContext :: IsSession o => Ptr () -> IO (GValueConstruct o) Source #
sessionAsyncContext :: AttrLabelProxy "asyncContext" Source #
httpAliases
data SessionHttpAliasesPropertyInfo Source #
Instances
clearSessionHttpAliases :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionHttpAliases :: IsSession o => [Text] -> IO (GValueConstruct o) Source #
sessionHttpAliases :: AttrLabelProxy "httpAliases" Source #
httpsAliases
data SessionHttpsAliasesPropertyInfo Source #
Instances
clearSessionHttpsAliases :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionHttpsAliases :: IsSession o => [Text] -> IO (GValueConstruct o) Source #
sessionHttpsAliases :: AttrLabelProxy "httpsAliases" Source #
idleTimeout
data SessionIdleTimeoutPropertyInfo Source #
Instances
constructSessionIdleTimeout :: IsSession o => Word32 -> IO (GValueConstruct o) Source #
sessionIdleTimeout :: AttrLabelProxy "idleTimeout" Source #
localAddress
data SessionLocalAddressPropertyInfo Source #
Instances
constructSessionLocalAddress :: (IsSession o, IsAddress a) => a -> IO (GValueConstruct o) Source #
sessionLocalAddress :: AttrLabelProxy "localAddress" Source #
maxConns
data SessionMaxConnsPropertyInfo Source #
Instances
constructSessionMaxConns :: IsSession o => Int32 -> IO (GValueConstruct o) Source #
sessionMaxConns :: AttrLabelProxy "maxConns" Source #
maxConnsPerHost
data SessionMaxConnsPerHostPropertyInfo Source #
Instances
constructSessionMaxConnsPerHost :: IsSession o => Int32 -> IO (GValueConstruct o) Source #
sessionMaxConnsPerHost :: AttrLabelProxy "maxConnsPerHost" Source #
proxyResolver
data SessionProxyResolverPropertyInfo Source #
Instances
clearSessionProxyResolver :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionProxyResolver :: (IsSession o, IsProxyResolver a) => a -> IO (GValueConstruct o) Source #
getSessionProxyResolver :: (MonadIO m, IsSession o) => o -> m (Maybe ProxyResolver) Source #
sessionProxyResolver :: AttrLabelProxy "proxyResolver" Source #
setSessionProxyResolver :: (MonadIO m, IsSession o, IsProxyResolver a) => o -> a -> m () Source #
proxyUri
data SessionProxyUriPropertyInfo Source #
Instances
clearSessionProxyUri :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionProxyUri :: IsSession o => URI -> IO (GValueConstruct o) Source #
sessionProxyUri :: AttrLabelProxy "proxyUri" Source #
sslCaFile
data SessionSslCaFilePropertyInfo Source #
Instances
clearSessionSslCaFile :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionSslCaFile :: IsSession o => Text -> IO (GValueConstruct o) Source #
sessionSslCaFile :: AttrLabelProxy "sslCaFile" Source #
sslStrict
data SessionSslStrictPropertyInfo Source #
Instances
constructSessionSslStrict :: IsSession o => Bool -> IO (GValueConstruct o) Source #
sessionSslStrict :: AttrLabelProxy "sslStrict" Source #
sslUseSystemCaFile
data SessionSslUseSystemCaFilePropertyInfo Source #
Instances
constructSessionSslUseSystemCaFile :: IsSession o => Bool -> IO (GValueConstruct o) Source #
sessionSslUseSystemCaFile :: AttrLabelProxy "sslUseSystemCaFile" Source #
timeout
data SessionTimeoutPropertyInfo Source #
Instances
constructSessionTimeout :: IsSession o => Word32 -> IO (GValueConstruct o) Source #
sessionTimeout :: AttrLabelProxy "timeout" Source #
tlsDatabase
data SessionTlsDatabasePropertyInfo Source #
Instances
clearSessionTlsDatabase :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionTlsDatabase :: (IsSession o, IsTlsDatabase a) => a -> IO (GValueConstruct o) Source #
getSessionTlsDatabase :: (MonadIO m, IsSession o) => o -> m (Maybe TlsDatabase) Source #
sessionTlsDatabase :: AttrLabelProxy "tlsDatabase" Source #
setSessionTlsDatabase :: (MonadIO m, IsSession o, IsTlsDatabase a) => o -> a -> m () Source #
tlsInteraction
data SessionTlsInteractionPropertyInfo Source #
Instances
clearSessionTlsInteraction :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionTlsInteraction :: (IsSession o, IsTlsInteraction a) => a -> IO (GValueConstruct o) Source #
getSessionTlsInteraction :: (MonadIO m, IsSession o) => o -> m (Maybe TlsInteraction) Source #
sessionTlsInteraction :: AttrLabelProxy "tlsInteraction" Source #
setSessionTlsInteraction :: (MonadIO m, IsSession o, IsTlsInteraction a) => o -> a -> m () Source #
useNtlm
data SessionUseNtlmPropertyInfo Source #
Instances
constructSessionUseNtlm :: IsSession o => Bool -> IO (GValueConstruct o) Source #
sessionUseNtlm :: AttrLabelProxy "useNtlm" Source #
useThreadContext
data SessionUseThreadContextPropertyInfo Source #
Instances
constructSessionUseThreadContext :: IsSession o => Bool -> IO (GValueConstruct o) Source #
sessionUseThreadContext :: AttrLabelProxy "useThreadContext" Source #
userAgent
data SessionUserAgentPropertyInfo Source #
Instances
clearSessionUserAgent :: (MonadIO m, IsSession o) => o -> m () Source #
constructSessionUserAgent :: IsSession o => Text -> IO (GValueConstruct o) Source #
sessionUserAgent :: AttrLabelProxy "userAgent" Source #
Signals
authenticate
type C_SessionAuthenticateCallback = Ptr () -> Ptr Message -> Ptr Auth -> CInt -> Ptr () -> IO () Source #
afterSessionAuthenticate :: (GObject a, MonadIO m) => a -> SessionAuthenticateCallback -> m SignalHandlerId Source #
mk_SessionAuthenticateCallback :: C_SessionAuthenticateCallback -> IO (FunPtr C_SessionAuthenticateCallback) Source #
onSessionAuthenticate :: (GObject a, MonadIO m) => a -> SessionAuthenticateCallback -> m SignalHandlerId Source #
wrap_SessionAuthenticateCallback :: SessionAuthenticateCallback -> Ptr () -> Ptr Message -> Ptr Auth -> CInt -> Ptr () -> IO () Source #
connectionCreated
type SessionConnectionCreatedCallback = Object -> IO () Source #
afterSessionConnectionCreated :: (GObject a, MonadIO m) => a -> SessionConnectionCreatedCallback -> m SignalHandlerId Source #
mk_SessionConnectionCreatedCallback :: C_SessionConnectionCreatedCallback -> IO (FunPtr C_SessionConnectionCreatedCallback) Source #
onSessionConnectionCreated :: (GObject a, MonadIO m) => a -> SessionConnectionCreatedCallback -> m SignalHandlerId Source #
wrap_SessionConnectionCreatedCallback :: SessionConnectionCreatedCallback -> Ptr () -> Ptr Object -> Ptr () -> IO () Source #
requestQueued
type SessionRequestQueuedCallback = Message -> IO () Source #
afterSessionRequestQueued :: (GObject a, MonadIO m) => a -> SessionRequestQueuedCallback -> m SignalHandlerId Source #
mk_SessionRequestQueuedCallback :: C_SessionRequestQueuedCallback -> IO (FunPtr C_SessionRequestQueuedCallback) Source #
onSessionRequestQueued :: (GObject a, MonadIO m) => a -> SessionRequestQueuedCallback -> m SignalHandlerId Source #
wrap_SessionRequestQueuedCallback :: SessionRequestQueuedCallback -> Ptr () -> Ptr Message -> Ptr () -> IO () Source #
requestStarted
type C_SessionRequestStartedCallback = Ptr () -> Ptr Message -> Ptr Socket -> Ptr () -> IO () Source #
type SessionRequestStartedCallback = Message -> Socket -> IO () Source #
Deprecated: (Since version 2.50.)Use Message::starting instead.
afterSessionRequestStarted :: (GObject a, MonadIO m) => a -> SessionRequestStartedCallback -> m SignalHandlerId Source #
mk_SessionRequestStartedCallback :: C_SessionRequestStartedCallback -> IO (FunPtr C_SessionRequestStartedCallback) Source #
onSessionRequestStarted :: (GObject a, MonadIO m) => a -> SessionRequestStartedCallback -> m SignalHandlerId Source #
wrap_SessionRequestStartedCallback :: SessionRequestStartedCallback -> Ptr () -> Ptr Message -> Ptr Socket -> Ptr () -> IO () Source #
requestUnqueued
type SessionRequestUnqueuedCallback = Message -> IO () Source #
afterSessionRequestUnqueued :: (GObject a, MonadIO m) => a -> SessionRequestUnqueuedCallback -> m SignalHandlerId Source #
mk_SessionRequestUnqueuedCallback :: C_SessionRequestUnqueuedCallback -> IO (FunPtr C_SessionRequestUnqueuedCallback) Source #
onSessionRequestUnqueued :: (GObject a, MonadIO m) => a -> SessionRequestUnqueuedCallback -> m SignalHandlerId Source #
wrap_SessionRequestUnqueuedCallback :: SessionRequestUnqueuedCallback -> Ptr () -> Ptr Message -> Ptr () -> IO () Source #
tunneling
type SessionTunnelingCallback = Object -> IO () Source #
afterSessionTunneling :: (GObject a, MonadIO m) => a -> SessionTunnelingCallback -> m SignalHandlerId Source #
mk_SessionTunnelingCallback :: C_SessionTunnelingCallback -> IO (FunPtr C_SessionTunnelingCallback) Source #
onSessionTunneling :: (GObject a, MonadIO m) => a -> SessionTunnelingCallback -> m SignalHandlerId Source #
wrap_SessionTunnelingCallback :: SessionTunnelingCallback -> Ptr () -> Ptr Object -> Ptr () -> IO () Source #