GI.Soup.Callbacks

Signals

AddressCallback

type AddressCallback = Address -> Word32 -> IO ()

type AddressCallback_WithClosures = Address -> Word32 -> Ptr () -> IO ()

type C_AddressCallback = Ptr Address -> Word32 -> Ptr () -> IO ()

drop_closures_AddressCallback :: AddressCallback -> AddressCallback_WithClosures

dynamic_AddressCallback

Arguments

:: (HasCallStack, MonadIO m, IsAddress a)

=> FunPtr C_AddressCallback

-> a

addr: the Address that was resolved

-> Word32

status: StatusOk, StatusCantResolve, or StatusCancelled

-> Ptr ()

userData: the user data that was passed to addressResolveAsync

-> m ()

genClosure_AddressCallback :: AddressCallback -> IO Closure

mk_AddressCallback :: C_AddressCallback -> IO (FunPtr C_AddressCallback)

noAddressCallback :: Maybe AddressCallback

noAddressCallback_WithClosures :: Maybe AddressCallback_WithClosures

wrap_AddressCallback :: Maybe (Ptr (FunPtr C_AddressCallback)) -> AddressCallback_WithClosures -> Ptr Address -> Word32 -> Ptr () -> IO ()

AuthDomainBasicAuthCallback

type AuthDomainBasicAuthCallback = AuthDomain -> Message -> Text -> Text -> IO Bool

type AuthDomainBasicAuthCallback_WithClosures = AuthDomain -> Message -> Text -> Text -> Ptr () -> IO Bool

type C_AuthDomainBasicAuthCallback = Ptr AuthDomain -> Ptr Message -> CString -> CString -> Ptr () -> IO CInt

drop_closures_AuthDomainBasicAuthCallback :: AuthDomainBasicAuthCallback -> AuthDomainBasicAuthCallback_WithClosures

dynamic_AuthDomainBasicAuthCallback

Arguments

:: (HasCallStack, MonadIO m, IsAuthDomain a, IsMessage b)

=> FunPtr C_AuthDomainBasicAuthCallback

-> a

domain: the domain

-> b

msg: the message being authenticated

-> Text

username: the username provided by the client

-> Text

password: the password provided by the client

-> Ptr ()

userData: the data passed to authDomainBasicSetAuthCallback

-> m Bool

Returns: True if username and password are valid

genClosure_AuthDomainBasicAuthCallback :: AuthDomainBasicAuthCallback -> IO Closure

mk_AuthDomainBasicAuthCallback :: C_AuthDomainBasicAuthCallback -> IO (FunPtr C_AuthDomainBasicAuthCallback)

noAuthDomainBasicAuthCallback :: Maybe AuthDomainBasicAuthCallback

noAuthDomainBasicAuthCallback_WithClosures :: Maybe AuthDomainBasicAuthCallback_WithClosures

wrap_AuthDomainBasicAuthCallback :: Maybe (Ptr (FunPtr C_AuthDomainBasicAuthCallback)) -> AuthDomainBasicAuthCallback_WithClosures -> Ptr AuthDomain -> Ptr Message -> CString -> CString -> Ptr () -> IO CInt

AuthDomainDigestAuthCallback

type AuthDomainDigestAuthCallback = AuthDomain -> Message -> Text -> IO (Maybe Text)

type AuthDomainDigestAuthCallback_WithClosures = AuthDomain -> Message -> Text -> Ptr () -> IO (Maybe Text)

type C_AuthDomainDigestAuthCallback = Ptr AuthDomain -> Ptr Message -> CString -> Ptr () -> IO CString

drop_closures_AuthDomainDigestAuthCallback :: AuthDomainDigestAuthCallback -> AuthDomainDigestAuthCallback_WithClosures

dynamic_AuthDomainDigestAuthCallback

Arguments

:: (HasCallStack, MonadIO m, IsAuthDomain a, IsMessage b)

=> FunPtr C_AuthDomainDigestAuthCallback

-> a

domain: the domain

-> b

msg: the message being authenticated

-> Text

username: the username provided by the client

-> Ptr ()

userData: the data passed to authDomainDigestSetAuthCallback

-> m (Maybe Text)

Returns: the encoded password, or Nothing if username is not a valid user. domain will free the password when it is done with it.

genClosure_AuthDomainDigestAuthCallback :: AuthDomainDigestAuthCallback -> IO Closure

mk_AuthDomainDigestAuthCallback :: C_AuthDomainDigestAuthCallback -> IO (FunPtr C_AuthDomainDigestAuthCallback)

noAuthDomainDigestAuthCallback :: Maybe AuthDomainDigestAuthCallback

noAuthDomainDigestAuthCallback_WithClosures :: Maybe AuthDomainDigestAuthCallback_WithClosures

wrap_AuthDomainDigestAuthCallback :: Maybe (Ptr (FunPtr C_AuthDomainDigestAuthCallback)) -> AuthDomainDigestAuthCallback_WithClosures -> Ptr AuthDomain -> Ptr Message -> CString -> Ptr () -> IO CString

AuthDomainFilter

type AuthDomainFilter = AuthDomain -> Message -> IO Bool

type AuthDomainFilter_WithClosures = AuthDomain -> Message -> Ptr () -> IO Bool

type C_AuthDomainFilter = Ptr AuthDomain -> Ptr Message -> Ptr () -> IO CInt

drop_closures_AuthDomainFilter :: AuthDomainFilter -> AuthDomainFilter_WithClosures

dynamic_AuthDomainFilter

Arguments

:: (HasCallStack, MonadIO m, IsAuthDomain a, IsMessage b)

=> FunPtr C_AuthDomainFilter

-> a

domain: a AuthDomain

-> b

msg: a Message

-> Ptr ()

userData: the data passed to authDomainSetFilter

-> m Bool

Returns: True if msg requires authentication, False if not.

genClosure_AuthDomainFilter :: AuthDomainFilter -> IO Closure

mk_AuthDomainFilter :: C_AuthDomainFilter -> IO (FunPtr C_AuthDomainFilter)

noAuthDomainFilter :: Maybe AuthDomainFilter

noAuthDomainFilter_WithClosures :: Maybe AuthDomainFilter_WithClosures

wrap_AuthDomainFilter :: Maybe (Ptr (FunPtr C_AuthDomainFilter)) -> AuthDomainFilter_WithClosures -> Ptr AuthDomain -> Ptr Message -> Ptr () -> IO CInt

AuthDomainGenericAuthCallback

type AuthDomainGenericAuthCallback = AuthDomain -> Message -> Text -> IO Bool

type AuthDomainGenericAuthCallback_WithClosures = AuthDomain -> Message -> Text -> Ptr () -> IO Bool

type C_AuthDomainGenericAuthCallback = Ptr AuthDomain -> Ptr Message -> CString -> Ptr () -> IO CInt

drop_closures_AuthDomainGenericAuthCallback :: AuthDomainGenericAuthCallback -> AuthDomainGenericAuthCallback_WithClosures

dynamic_AuthDomainGenericAuthCallback

Arguments

:: (HasCallStack, MonadIO m, IsAuthDomain a, IsMessage b)

=> FunPtr C_AuthDomainGenericAuthCallback

-> a

domain: a AuthDomain

-> b

msg: the Message being authenticated

-> Text

username: the username from msg

-> Ptr ()

userData: the data passed to authDomainSetGenericAuthCallback

-> m Bool

Returns: True if msg is authenticated, False if not.

genClosure_AuthDomainGenericAuthCallback :: AuthDomainGenericAuthCallback -> IO Closure

mk_AuthDomainGenericAuthCallback :: C_AuthDomainGenericAuthCallback -> IO (FunPtr C_AuthDomainGenericAuthCallback)

noAuthDomainGenericAuthCallback :: Maybe AuthDomainGenericAuthCallback

noAuthDomainGenericAuthCallback_WithClosures :: Maybe AuthDomainGenericAuthCallback_WithClosures

wrap_AuthDomainGenericAuthCallback :: Maybe (Ptr (FunPtr C_AuthDomainGenericAuthCallback)) -> AuthDomainGenericAuthCallback_WithClosures -> Ptr AuthDomain -> Ptr Message -> CString -> Ptr () -> IO CInt

ChunkAllocator

type C_ChunkAllocator = Ptr Message -> Word64 -> Ptr () -> IO (Ptr Buffer)

type ChunkAllocator = Message -> Word64 -> IO (Maybe Buffer)

Deprecated: Use Request if you want to read into yourown buffers.

type ChunkAllocator_WithClosures = Message -> Word64 -> Ptr () -> IO (Maybe Buffer)

drop_closures_ChunkAllocator :: ChunkAllocator -> ChunkAllocator_WithClosures

dynamic_ChunkAllocator

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> FunPtr C_ChunkAllocator

-> a

msg: the Message the chunk is being allocated for

-> Word64

maxLen: the maximum length that will be read, or 0.

-> Ptr ()

userData: the data passed to messageSetChunkAllocator

-> m (Maybe Buffer)

Returns: the new buffer (or Nothing)

genClosure_ChunkAllocator :: ChunkAllocator -> IO Closure

mk_ChunkAllocator :: C_ChunkAllocator -> IO (FunPtr C_ChunkAllocator)

noChunkAllocator :: Maybe ChunkAllocator

noChunkAllocator_WithClosures :: Maybe ChunkAllocator_WithClosures

wrap_ChunkAllocator :: Maybe (Ptr (FunPtr C_ChunkAllocator)) -> ChunkAllocator_WithClosures -> Ptr Message -> Word64 -> Ptr () -> IO (Ptr Buffer)

LoggerFilter

type C_LoggerFilter = Ptr Logger -> Ptr Message -> Ptr () -> IO CUInt

type LoggerFilter = Logger -> Message -> IO LoggerLogLevel

type LoggerFilter_WithClosures = Logger -> Message -> Ptr () -> IO LoggerLogLevel

drop_closures_LoggerFilter :: LoggerFilter -> LoggerFilter_WithClosures

dynamic_LoggerFilter

Arguments

:: (HasCallStack, MonadIO m, IsLogger a, IsMessage b)

=> FunPtr C_LoggerFilter

-> a

logger: the Logger

-> b

msg: the message being logged

-> Ptr ()

userData: the data passed to loggerSetRequestFilter or loggerSetResponseFilter

-> m LoggerLogLevel

Returns: a LoggerLogLevel value indicating how much of the message to log

genClosure_LoggerFilter :: LoggerFilter -> IO Closure

mk_LoggerFilter :: C_LoggerFilter -> IO (FunPtr C_LoggerFilter)

noLoggerFilter :: Maybe LoggerFilter

noLoggerFilter_WithClosures :: Maybe LoggerFilter_WithClosures

wrap_LoggerFilter :: Maybe (Ptr (FunPtr C_LoggerFilter)) -> LoggerFilter_WithClosures -> Ptr Logger -> Ptr Message -> Ptr () -> IO CUInt

LoggerPrinter

type C_LoggerPrinter = Ptr Logger -> CUInt -> Int8 -> CString -> Ptr () -> IO ()

type LoggerPrinter = Logger -> LoggerLogLevel -> Int8 -> Text -> IO ()

type LoggerPrinter_WithClosures = Logger -> LoggerLogLevel -> Int8 -> Text -> Ptr () -> IO ()

drop_closures_LoggerPrinter :: LoggerPrinter -> LoggerPrinter_WithClosures

dynamic_LoggerPrinter

Arguments

:: (HasCallStack, MonadIO m, IsLogger a)

=> FunPtr C_LoggerPrinter

-> a

logger: the Logger

-> LoggerLogLevel

level: the level of the information being printed.

-> Int8

direction: a single-character prefix to data

-> Text

data: data to print

-> Ptr ()

userData: the data passed to loggerSetPrinter

-> m ()

genClosure_LoggerPrinter :: LoggerPrinter -> IO Closure

mk_LoggerPrinter :: C_LoggerPrinter -> IO (FunPtr C_LoggerPrinter)

noLoggerPrinter :: Maybe LoggerPrinter

noLoggerPrinter_WithClosures :: Maybe LoggerPrinter_WithClosures

wrap_LoggerPrinter :: Maybe (Ptr (FunPtr C_LoggerPrinter)) -> LoggerPrinter_WithClosures -> Ptr Logger -> CUInt -> Int8 -> CString -> Ptr () -> IO ()

MessageHeadersForeachFunc

type C_MessageHeadersForeachFunc = CString -> CString -> Ptr () -> IO ()

type MessageHeadersForeachFunc = Text -> Text -> IO ()

type MessageHeadersForeachFunc_WithClosures = Text -> Text -> Ptr () -> IO ()

drop_closures_MessageHeadersForeachFunc :: MessageHeadersForeachFunc -> MessageHeadersForeachFunc_WithClosures

dynamic_MessageHeadersForeachFunc

Arguments

:: (HasCallStack, MonadIO m)

=> FunPtr C_MessageHeadersForeachFunc

-> Text

name: the header name

-> Text

value: the header value

-> Ptr ()

userData: the data passed to messageHeadersForeach

-> m ()

genClosure_MessageHeadersForeachFunc :: MessageHeadersForeachFunc -> IO Closure

mk_MessageHeadersForeachFunc :: C_MessageHeadersForeachFunc -> IO (FunPtr C_MessageHeadersForeachFunc)

noMessageHeadersForeachFunc :: Maybe MessageHeadersForeachFunc

noMessageHeadersForeachFunc_WithClosures :: Maybe MessageHeadersForeachFunc_WithClosures

wrap_MessageHeadersForeachFunc :: Maybe (Ptr (FunPtr C_MessageHeadersForeachFunc)) -> MessageHeadersForeachFunc_WithClosures -> CString -> CString -> Ptr () -> IO ()

PasswordManagerCallback

type C_PasswordManagerCallback = Ptr PasswordManager -> Ptr Message -> Ptr Auth -> CInt -> Ptr () -> IO ()

type PasswordManagerCallback = PasswordManager -> Message -> Auth -> Bool -> IO ()

type PasswordManagerCallback_WithClosures = PasswordManager -> Message -> Auth -> Bool -> Ptr () -> IO ()

drop_closures_PasswordManagerCallback :: PasswordManagerCallback -> PasswordManagerCallback_WithClosures

dynamic_PasswordManagerCallback :: (HasCallStack, MonadIO m, IsPasswordManager a, IsMessage b, IsAuth c) => FunPtr C_PasswordManagerCallback -> a -> b -> c -> Bool -> Ptr () -> m ()

genClosure_PasswordManagerCallback :: PasswordManagerCallback -> IO Closure

mk_PasswordManagerCallback :: C_PasswordManagerCallback -> IO (FunPtr C_PasswordManagerCallback)

noPasswordManagerCallback :: Maybe PasswordManagerCallback

noPasswordManagerCallback_WithClosures :: Maybe PasswordManagerCallback_WithClosures

wrap_PasswordManagerCallback :: Maybe (Ptr (FunPtr C_PasswordManagerCallback)) -> PasswordManagerCallback_WithClosures -> Ptr PasswordManager -> Ptr Message -> Ptr Auth -> CInt -> Ptr () -> IO ()

ProxyURIResolverCallback

type C_ProxyURIResolverCallback = Ptr ProxyURIResolver -> Word32 -> Ptr URI -> Ptr () -> IO ()

type ProxyURIResolverCallback = ProxyURIResolver -> Word32 -> URI -> IO ()

type ProxyURIResolverCallback_WithClosures = ProxyURIResolver -> Word32 -> URI -> Ptr () -> IO ()

drop_closures_ProxyURIResolverCallback :: ProxyURIResolverCallback -> ProxyURIResolverCallback_WithClosures

dynamic_ProxyURIResolverCallback

Arguments

:: (HasCallStack, MonadIO m, IsProxyURIResolver a)

=> FunPtr C_ProxyURIResolverCallback

-> a

resolver: the ProxyURIResolver

-> Word32

status: a Status

-> URI

proxyUri: the resolved proxy URI, or Nothing

-> Ptr ()

userData: data passed to proxyURIResolverGetProxyUriAsync

-> m ()

genClosure_ProxyURIResolverCallback :: ProxyURIResolverCallback -> IO Closure

mk_ProxyURIResolverCallback :: C_ProxyURIResolverCallback -> IO (FunPtr C_ProxyURIResolverCallback)

noProxyURIResolverCallback :: Maybe ProxyURIResolverCallback

noProxyURIResolverCallback_WithClosures :: Maybe ProxyURIResolverCallback_WithClosures

wrap_ProxyURIResolverCallback :: Maybe (Ptr (FunPtr C_ProxyURIResolverCallback)) -> ProxyURIResolverCallback_WithClosures -> Ptr ProxyURIResolver -> Word32 -> Ptr URI -> Ptr () -> IO ()

ServerCallback

type C_ServerCallback = Ptr Server -> Ptr Message -> CString -> Ptr (GHashTable CString CString) -> Ptr ClientContext -> Ptr () -> IO ()

type ServerCallback = Server -> Message -> Text -> Maybe (Map Text Text) -> ClientContext -> IO ()

type ServerCallback_WithClosures = Server -> Message -> Text -> Maybe (Map Text Text) -> ClientContext -> Ptr () -> IO ()

drop_closures_ServerCallback :: ServerCallback -> ServerCallback_WithClosures

dynamic_ServerCallback

Arguments

:: (HasCallStack, MonadIO m, IsServer a, IsMessage b)

=> FunPtr C_ServerCallback

-> a

server: the Server

-> b

msg: the message being processed

-> Text

path: the path component of msg's Request-URI

-> Maybe (Map Text Text)

query: the parsed query component of msg's Request-URI

-> ClientContext

client: additional contextual information about the client

-> Ptr ()

userData: the data passed to serverAddHandler or serverAddEarlyHandler.

-> m ()

genClosure_ServerCallback :: ServerCallback -> IO Closure

mk_ServerCallback :: C_ServerCallback -> IO (FunPtr C_ServerCallback)

noServerCallback :: Maybe ServerCallback

noServerCallback_WithClosures :: Maybe ServerCallback_WithClosures

wrap_ServerCallback :: Maybe (Ptr (FunPtr C_ServerCallback)) -> ServerCallback_WithClosures -> Ptr Server -> Ptr Message -> CString -> Ptr (GHashTable CString CString) -> Ptr ClientContext -> Ptr () -> IO ()

ServerWebsocketCallback

type C_ServerWebsocketCallback = Ptr Server -> Ptr WebsocketConnection -> CString -> Ptr ClientContext -> Ptr () -> IO ()

type ServerWebsocketCallback = Server -> WebsocketConnection -> Text -> ClientContext -> IO ()

type ServerWebsocketCallback_WithClosures = Server -> WebsocketConnection -> Text -> ClientContext -> Ptr () -> IO ()

drop_closures_ServerWebsocketCallback :: ServerWebsocketCallback -> ServerWebsocketCallback_WithClosures

dynamic_ServerWebsocketCallback

Arguments

:: (HasCallStack, MonadIO m, IsServer a, IsWebsocketConnection b)

=> FunPtr C_ServerWebsocketCallback

-> a

server: the Server

-> b

connection: the newly created WebSocket connection

-> Text

path: the path component of msg's Request-URI

-> ClientContext

client: additional contextual information about the client

-> Ptr ()

userData: the data passed to soupServerAddHandler

-> m ()

genClosure_ServerWebsocketCallback :: ServerWebsocketCallback -> IO Closure

mk_ServerWebsocketCallback :: C_ServerWebsocketCallback -> IO (FunPtr C_ServerWebsocketCallback)

noServerWebsocketCallback :: Maybe ServerWebsocketCallback

noServerWebsocketCallback_WithClosures :: Maybe ServerWebsocketCallback_WithClosures

wrap_ServerWebsocketCallback :: Maybe (Ptr (FunPtr C_ServerWebsocketCallback)) -> ServerWebsocketCallback_WithClosures -> Ptr Server -> Ptr WebsocketConnection -> CString -> Ptr ClientContext -> Ptr () -> IO ()

SessionCallback

type C_SessionCallback = Ptr Session -> Ptr Message -> Ptr () -> IO ()

type SessionCallback = Session -> Message -> IO ()

type SessionCallback_WithClosures = Session -> Message -> Ptr () -> IO ()

drop_closures_SessionCallback :: SessionCallback -> SessionCallback_WithClosures

dynamic_SessionCallback

Arguments

:: (HasCallStack, MonadIO m, IsSession a, IsMessage b)

=> FunPtr C_SessionCallback

-> a

session: the session

-> b

msg: the message that has finished

-> Ptr ()

userData: the data passed to soup_session_queue_message

-> m ()

genClosure_SessionCallback :: SessionCallback -> IO Closure

mk_SessionCallback :: C_SessionCallback -> IO (FunPtr C_SessionCallback)

noSessionCallback :: Maybe SessionCallback

noSessionCallback_WithClosures :: Maybe SessionCallback_WithClosures

wrap_SessionCallback :: Maybe (Ptr (FunPtr C_SessionCallback)) -> SessionCallback_WithClosures -> Ptr Session -> Ptr Message -> Ptr () -> IO ()

SocketCallback

type C_SocketCallback = Ptr Socket -> Word32 -> Ptr () -> IO ()

type SocketCallback = Socket -> Word32 -> IO ()

type SocketCallback_WithClosures = Socket -> Word32 -> Ptr () -> IO ()

drop_closures_SocketCallback :: SocketCallback -> SocketCallback_WithClosures

dynamic_SocketCallback

Arguments

:: (HasCallStack, MonadIO m, IsSocket a)

=> FunPtr C_SocketCallback

-> a

sock: the Socket

-> Word32

status: an HTTP status code indicating success or failure

-> Ptr ()

userData: the data passed to socketConnectAsync

-> m ()

genClosure_SocketCallback :: SocketCallback -> IO Closure

mk_SocketCallback :: C_SocketCallback -> IO (FunPtr C_SocketCallback)

noSocketCallback :: Maybe SocketCallback

noSocketCallback_WithClosures :: Maybe SocketCallback_WithClosures

wrap_SocketCallback :: Maybe (Ptr (FunPtr C_SocketCallback)) -> SocketCallback_WithClosures -> Ptr Socket -> Word32 -> Ptr () -> IO ()