GI.Soup.Objects.Message

Represents an HTTP message being sent or received.

statusCode will normally be a Status value, eg, StatusOk, though of course it might actually be an unknown status code. reasonPhrase is the actual text returned from the server, which may or may not correspond to the "standard" description of statusCode. At any rate, it is almost certainly not localized, and not very descriptive even if it is in the user's language; you should not use reasonPhrase in user-visible messages. Rather, you should look at statusCode, and determine an end-user-appropriate message based on that and on what you were trying to do.

As described in the MessageBody documentation, the requestBody and responseBody <literal>data</literal> fields will not necessarily be filled in at all times. When the body fields are filled in, they will be terminated with a '\0' byte (which is not included in the <literal>length</literal>), so you can use them as ordinary C strings (assuming that you know that the body doesn't have any other '\0' bytes).

For a client-side Message, requestBody's <literal>data</literal> is usually filled in right before libsoup writes the request to the network, but you should not count on this; use messageBodyFlatten if you want to ensure that <literal>data</literal> is filled in. If you are not using Request to read the response, then responseBody's <literal>data</literal> will be filled in before Message::finished is emitted. (If you are using Request, then the message body is not accumulated by default, so responseBody's <literal>data</literal> will always be Nothing.)

For a server-side Message, requestBody's data will be filled in before Message::got_body is emitted.

To prevent the data field from being filled in at all (eg, if you are handling the data from a Message::got_chunk, and so don't need to see it all at the end), call messageBodySetAccumulate on responseBody or requestBody as appropriate, passing False.

Exported types

newtype Message

Constructors

Message (ManagedPtr Message)

Instances

GObject Message

Methods

gobjectType :: Message -> IO GType

IsObject Message

IsMessage Message

class GObject o => IsMessage o

Instances

(GObject a, UnknownAncestorError Constraint Message a) => IsMessage a

IsMessage Message

toMessage :: (MonadIO m, IsMessage o) => o -> m Message

noMessage :: Maybe Message

Methods

contentSniffed

messageContentSniffed :: (HasCallStack, MonadIO m, IsMessage a) => a -> Text -> Map (Ptr ()) (Ptr ()) -> m ()

No description available in the introspection data.

disableFeature

messageDisableFeature

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> GType

featureType: the GType of a SessionFeature

-> m ()

This disables the actions of SessionFeature<!-- -->s with the given featureType (or a subclass of that type) on msg, so that msg is processed as though the feature(s) hadn't been added to the session. Eg, passing SOUP_TYPE_CONTENT_SNIFFER for featureType will disable Content-Type sniffing on the message.

You must call this before queueing msg on a session; calling it on a message that has already been queued is undefined. In particular, you cannot call this on a message that is being requeued after a redirect or authentication.

Since: 2.28

finished

messageFinished :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

getAddress

messageGetAddress

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m Address

Returns: the address msg's URI points to

Gets the address msg's URI points to. After first setting the URI on a message, this will be unresolved, although the message's session will resolve it before sending the message.

Since: 2.26

getFirstParty

messageGetFirstParty

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m URI

Returns: the msg's first party URI

Gets msg's first-party URI

Since: 2.30

getFlags

messageGetFlags

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m [MessageFlags]

Returns: the flags

Gets the flags on msg

getHttpVersion

messageGetHttpVersion

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m HTTPVersion

Returns: the HTTP version

Gets the HTTP version of msg. This is the minimum of the version from the request and the version from the response.

getHttpsStatus

messageGetHttpsStatus

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m (Bool, TlsCertificate, [TlsCertificateFlags])

Returns: True if msg used/attempted https, False if not

If msg is using https (or attempted to use https but got StatusSslFailed), this retrieves the TlsCertificate associated with its connection, and the TlsCertificateFlags showing what problems, if any, have been found with that certificate.

<note><para>This is only meaningful with messages processed by a Session and is not useful for messages received by a Server</para></note>

Since: 2.34

getPriority

messageGetPriority

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m MessagePriority

Returns: the priority of the message.

Retrieves the MessagePriority. If not set this value defaults to SOUP_MESSAGE_PRIORITY_NORMAL.

Since: 2.44

getSoupRequest

messageGetSoupRequest

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m Request

Returns: msg's associated Request

If msg is associated with a Request, this returns that request. Otherwise it returns Nothing.

Since: 2.42

getUri

messageGetUri

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m URI

Returns: the URI msg is targeted for.

Gets msg's URI

gotBody

messageGotBody :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

gotChunk

messageGotChunk :: (HasCallStack, MonadIO m, IsMessage a) => a -> Buffer -> m ()

No description available in the introspection data.

gotHeaders

messageGotHeaders :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

gotInformational

messageGotInformational :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

isKeepalive

messageIsKeepalive

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> m Bool

Returns: True or False.

Determines whether or not msg's connection can be kept alive for further requests after processing msg, based on the HTTP version, Connection header, etc.

new

messageNew

Arguments

:: (HasCallStack, MonadIO m)

=> Text

method: the HTTP method for the created request

-> Text

uriString: the destination endpoint (as a string)

-> m (Maybe Message)

Returns: the new Message (or Nothing if uri could not be parsed).

Creates a new empty Message, which will connect to uri

newFromUri

messageNewFromUri

Arguments

:: (HasCallStack, MonadIO m)

=> Text

method: the HTTP method for the created request

-> URI

uri: the destination endpoint (as a URI)

-> m Message

Returns: the new Message

Creates a new empty Message, which will connect to uri

restarted

messageRestarted :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

setChunkAllocator

messageSetChunkAllocator

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> ChunkAllocator

allocator: the chunk allocator callback

-> m ()

Deprecated: Request provides a much simpler API that lets youread the response directly into your own buffers without needing tomess with callbacks, pausing/unpausing, etc.

Sets an alternate chunk-allocation function to use when reading msg's body when using the traditional (ie, non-Request<!-- -->-based) API. Every time data is available to read, libsoup will call allocator, which should return a Buffer. (See ChunkAllocator for additional details.) Libsoup will then read data from the network into that buffer, and update the buffer's <literal>length</literal> to indicate how much data it read.

Generally, a custom chunk allocator would be used in conjunction with messageBodySetAccumulate False and Message::got_chunk, as part of a strategy to avoid unnecessary copying of data. However, you cannot assume that every call to the allocator will be followed by a call to your Message::got_chunk handler; if an I/O error occurs, then the buffer will be unreffed without ever having been used. If your buffer-allocation strategy requires special cleanup, use bufferNewWithOwner rather than doing the cleanup from the Message::got_chunk handler.

The other thing to remember when using non-accumulating message bodies is that the buffer passed to the Message::got_chunk handler will be unreffed after the handler returns, just as it would be in the non-custom-allocated case. If you want to hand the chunk data off to some other part of your program to use later, you'll need to ref the Buffer (or its owner, in the bufferNewWithOwner case) to ensure that the data remains valid.

setFirstParty

messageSetFirstParty

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> URI

firstParty: the URI for the msg's first party

-> m ()

Sets firstParty as the main document URI for msg. For details of when and how this is used refer to the documentation for CookieJarAcceptPolicy.

Since: 2.30

setFlags

messageSetFlags

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> [MessageFlags]

flags: a set of MessageFlags values

-> m ()

Sets the specified flags on msg.

setHttpVersion

messageSetHttpVersion

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> HTTPVersion

version: the HTTP version

-> m ()

Sets the HTTP version on msg. The default version is HTTPVersionHttp11. Setting it to HTTPVersionHttp10 will prevent certain functionality from being used.

setPriority

messageSetPriority

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> MessagePriority

priority: the MessagePriority

-> m ()

Sets the priority of a message. Note that this won't have any effect unless used before the message is added to the session's message processing queue.

The message will be placed just before any other previously added message with lower priority (messages with the same priority are processed on a FIFO basis).

Setting priorities does not currently work with SessionSync (or with synchronous messages on a plain Session) because in the synchronous/blocking case, priority ends up being determined semi-randomly by thread scheduling.

Since: 2.44

setRedirect

messageSetRedirect

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> Word32

statusCode: a 3xx status code

-> Text

redirectUri: the URI to redirect msg to

-> m ()

Sets msg's status_code to statusCode and adds a Location header pointing to redirectUri. Use this from a Server when you want to redirect the client to another URI.

redirectUri can be a relative URI, in which case it is interpreted relative to msg's current URI. In particular, if redirectUri is just a path, it will replace the path <emphasis>and query</emphasis> of msg's URI.

Since: 2.38

setRequest

messageSetRequest

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: the message

-> Maybe Text

contentType: MIME Content-Type of the body

-> MemoryUse

reqUse: a MemoryUse describing how to handle reqBody

-> Maybe ByteString

reqBody: a data buffer containing the body of the message request.

-> m ()

Convenience function to set the request body of a Message. If contentType is Nothing, the request body must be empty as well.

setResponse

messageSetResponse

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: the message

-> Maybe Text

contentType: MIME Content-Type of the body

-> MemoryUse

respUse: a MemoryUse describing how to handle respBody

-> Maybe ByteString

respBody: a data buffer containing the body of the message response.

-> m ()

Convenience function to set the response body of a Message. If contentType is Nothing, the response body must be empty as well.

setStatus

messageSetStatus

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> Word32

statusCode: an HTTP status code

-> m ()

Sets msg's status code to statusCode. If statusCode is a known value, it will also set msg's reason_phrase.

setStatusFull

messageSetStatusFull

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> Word32

statusCode: an HTTP status code

-> Text

reasonPhrase: a description of the status

-> m ()

Sets msg's status code and reason phrase.

setUri

messageSetUri

Arguments

:: (HasCallStack, MonadIO m, IsMessage a)

=> a

msg: a Message

-> URI

uri: the new URI

-> m ()

Sets msg's URI to uri. If msg has already been sent and you want to re-send it with the new URI, you need to call sessionRequeueMessage.

starting

messageStarting :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

wroteBody

messageWroteBody :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

wroteBodyData

messageWroteBodyData :: (HasCallStack, MonadIO m, IsMessage a) => a -> Buffer -> m ()

No description available in the introspection data.

wroteChunk

messageWroteChunk :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

wroteHeaders

messageWroteHeaders :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

wroteInformational

messageWroteInformational :: (HasCallStack, MonadIO m, IsMessage a) => a -> m ()

No description available in the introspection data.

Properties

firstParty

constructMessageFirstParty :: IsMessage o => URI -> IO (GValueConstruct o)

getMessageFirstParty :: (MonadIO m, IsMessage o) => o -> m URI

setMessageFirstParty :: (MonadIO m, IsMessage o) => o -> URI -> m ()

flags

constructMessageFlags :: IsMessage o => [MessageFlags] -> IO (GValueConstruct o)

getMessageFlags :: (MonadIO m, IsMessage o) => o -> m [MessageFlags]

setMessageFlags :: (MonadIO m, IsMessage o) => o -> [MessageFlags] -> m ()

httpVersion

constructMessageHttpVersion :: IsMessage o => HTTPVersion -> IO (GValueConstruct o)

getMessageHttpVersion :: (MonadIO m, IsMessage o) => o -> m HTTPVersion

setMessageHttpVersion :: (MonadIO m, IsMessage o) => o -> HTTPVersion -> m ()

method

clearMessageMethod :: (MonadIO m, IsMessage o) => o -> m ()

constructMessageMethod :: IsMessage o => Text -> IO (GValueConstruct o)

getMessageMethod :: (MonadIO m, IsMessage o) => o -> m (Maybe Text)

setMessageMethod :: (MonadIO m, IsMessage o) => o -> Text -> m ()

priority

constructMessagePriority :: IsMessage o => MessagePriority -> IO (GValueConstruct o)

getMessagePriority :: (MonadIO m, IsMessage o) => o -> m MessagePriority

setMessagePriority :: (MonadIO m, IsMessage o) => o -> MessagePriority -> m ()

reasonPhrase

clearMessageReasonPhrase :: (MonadIO m, IsMessage o) => o -> m ()

constructMessageReasonPhrase :: IsMessage o => Text -> IO (GValueConstruct o)

getMessageReasonPhrase :: (MonadIO m, IsMessage o) => o -> m (Maybe Text)

setMessageReasonPhrase :: (MonadIO m, IsMessage o) => o -> Text -> m ()

requestBody

getMessageRequestBody :: (MonadIO m, IsMessage o) => o -> m (Maybe MessageBody)

requestBodyData

getMessageRequestBodyData :: (MonadIO m, IsMessage o) => o -> m (Maybe Bytes)

requestHeaders

getMessageRequestHeaders :: (MonadIO m, IsMessage o) => o -> m (Maybe MessageHeaders)

responseBody

getMessageResponseBody :: (MonadIO m, IsMessage o) => o -> m (Maybe MessageBody)

responseBodyData

getMessageResponseBodyData :: (MonadIO m, IsMessage o) => o -> m (Maybe Bytes)

responseHeaders

getMessageResponseHeaders :: (MonadIO m, IsMessage o) => o -> m (Maybe MessageHeaders)

serverSide

constructMessageServerSide :: IsMessage o => Bool -> IO (GValueConstruct o)

getMessageServerSide :: (MonadIO m, IsMessage o) => o -> m Bool

statusCode

constructMessageStatusCode :: IsMessage o => Word32 -> IO (GValueConstruct o)

getMessageStatusCode :: (MonadIO m, IsMessage o) => o -> m Word32

setMessageStatusCode :: (MonadIO m, IsMessage o) => o -> Word32 -> m ()

tlsCertificate

clearMessageTlsCertificate :: (MonadIO m, IsMessage o) => o -> m ()

constructMessageTlsCertificate :: (IsMessage o, IsTlsCertificate a) => a -> IO (GValueConstruct o)

getMessageTlsCertificate :: (MonadIO m, IsMessage o) => o -> m (Maybe TlsCertificate)

setMessageTlsCertificate :: (MonadIO m, IsMessage o, IsTlsCertificate a) => o -> a -> m ()

tlsErrors

constructMessageTlsErrors :: IsMessage o => [TlsCertificateFlags] -> IO (GValueConstruct o)

getMessageTlsErrors :: (MonadIO m, IsMessage o) => o -> m [TlsCertificateFlags]

setMessageTlsErrors :: (MonadIO m, IsMessage o) => o -> [TlsCertificateFlags] -> m ()

uri

constructMessageUri :: IsMessage o => URI -> IO (GValueConstruct o)

getMessageUri :: (MonadIO m, IsMessage o) => o -> m URI

setMessageUri :: (MonadIO m, IsMessage o) => o -> URI -> m ()

Signals

contentSniffed

type C_MessageContentSniffedCallback = Ptr () -> CString -> Ptr (GHashTable CString CString) -> Ptr () -> IO ()

type MessageContentSniffedCallback = Text -> Map Text Text -> IO ()

afterMessageContentSniffed :: (IsMessage a, MonadIO m) => a -> MessageContentSniffedCallback -> m SignalHandlerId

genClosure_MessageContentSniffed :: MessageContentSniffedCallback -> IO Closure

mk_MessageContentSniffedCallback :: C_MessageContentSniffedCallback -> IO (FunPtr C_MessageContentSniffedCallback)

noMessageContentSniffedCallback :: Maybe MessageContentSniffedCallback

onMessageContentSniffed :: (IsMessage a, MonadIO m) => a -> MessageContentSniffedCallback -> m SignalHandlerId

wrap_MessageContentSniffedCallback :: MessageContentSniffedCallback -> Ptr () -> CString -> Ptr (GHashTable CString CString) -> Ptr () -> IO ()

finished

type C_MessageFinishedCallback = Ptr () -> Ptr () -> IO ()

type MessageFinishedCallback = IO ()

afterMessageFinished :: (IsMessage a, MonadIO m) => a -> MessageFinishedCallback -> m SignalHandlerId

genClosure_MessageFinished :: MessageFinishedCallback -> IO Closure

mk_MessageFinishedCallback :: C_MessageFinishedCallback -> IO (FunPtr C_MessageFinishedCallback)

noMessageFinishedCallback :: Maybe MessageFinishedCallback

onMessageFinished :: (IsMessage a, MonadIO m) => a -> MessageFinishedCallback -> m SignalHandlerId

wrap_MessageFinishedCallback :: MessageFinishedCallback -> Ptr () -> Ptr () -> IO ()

gotBody

type C_MessageGotBodyCallback = Ptr () -> Ptr () -> IO ()

type MessageGotBodyCallback = IO ()

afterMessageGotBody :: (IsMessage a, MonadIO m) => a -> MessageGotBodyCallback -> m SignalHandlerId

genClosure_MessageGotBody :: MessageGotBodyCallback -> IO Closure

mk_MessageGotBodyCallback :: C_MessageGotBodyCallback -> IO (FunPtr C_MessageGotBodyCallback)

noMessageGotBodyCallback :: Maybe MessageGotBodyCallback

onMessageGotBody :: (IsMessage a, MonadIO m) => a -> MessageGotBodyCallback -> m SignalHandlerId

wrap_MessageGotBodyCallback :: MessageGotBodyCallback -> Ptr () -> Ptr () -> IO ()

gotChunk

type C_MessageGotChunkCallback = Ptr () -> Ptr Buffer -> Ptr () -> IO ()

type MessageGotChunkCallback = Buffer -> IO ()

afterMessageGotChunk :: (IsMessage a, MonadIO m) => a -> MessageGotChunkCallback -> m SignalHandlerId

genClosure_MessageGotChunk :: MessageGotChunkCallback -> IO Closure

mk_MessageGotChunkCallback :: C_MessageGotChunkCallback -> IO (FunPtr C_MessageGotChunkCallback)

noMessageGotChunkCallback :: Maybe MessageGotChunkCallback

onMessageGotChunk :: (IsMessage a, MonadIO m) => a -> MessageGotChunkCallback -> m SignalHandlerId

wrap_MessageGotChunkCallback :: MessageGotChunkCallback -> Ptr () -> Ptr Buffer -> Ptr () -> IO ()

gotHeaders

type C_MessageGotHeadersCallback = Ptr () -> Ptr () -> IO ()

type MessageGotHeadersCallback = IO ()

afterMessageGotHeaders :: (IsMessage a, MonadIO m) => a -> MessageGotHeadersCallback -> m SignalHandlerId

genClosure_MessageGotHeaders :: MessageGotHeadersCallback -> IO Closure

mk_MessageGotHeadersCallback :: C_MessageGotHeadersCallback -> IO (FunPtr C_MessageGotHeadersCallback)

noMessageGotHeadersCallback :: Maybe MessageGotHeadersCallback

onMessageGotHeaders :: (IsMessage a, MonadIO m) => a -> MessageGotHeadersCallback -> m SignalHandlerId

wrap_MessageGotHeadersCallback :: MessageGotHeadersCallback -> Ptr () -> Ptr () -> IO ()

gotInformational

type C_MessageGotInformationalCallback = Ptr () -> Ptr () -> IO ()

type MessageGotInformationalCallback = IO ()

afterMessageGotInformational :: (IsMessage a, MonadIO m) => a -> MessageGotInformationalCallback -> m SignalHandlerId

genClosure_MessageGotInformational :: MessageGotInformationalCallback -> IO Closure

mk_MessageGotInformationalCallback :: C_MessageGotInformationalCallback -> IO (FunPtr C_MessageGotInformationalCallback)

noMessageGotInformationalCallback :: Maybe MessageGotInformationalCallback

onMessageGotInformational :: (IsMessage a, MonadIO m) => a -> MessageGotInformationalCallback -> m SignalHandlerId

wrap_MessageGotInformationalCallback :: MessageGotInformationalCallback -> Ptr () -> Ptr () -> IO ()

networkEvent

type C_MessageNetworkEventCallback = Ptr () -> CUInt -> Ptr IOStream -> Ptr () -> IO ()

type MessageNetworkEventCallback = SocketClientEvent -> IOStream -> IO ()

afterMessageNetworkEvent :: (IsMessage a, MonadIO m) => a -> MessageNetworkEventCallback -> m SignalHandlerId

genClosure_MessageNetworkEvent :: MessageNetworkEventCallback -> IO Closure

mk_MessageNetworkEventCallback :: C_MessageNetworkEventCallback -> IO (FunPtr C_MessageNetworkEventCallback)

noMessageNetworkEventCallback :: Maybe MessageNetworkEventCallback

onMessageNetworkEvent :: (IsMessage a, MonadIO m) => a -> MessageNetworkEventCallback -> m SignalHandlerId

wrap_MessageNetworkEventCallback :: MessageNetworkEventCallback -> Ptr () -> CUInt -> Ptr IOStream -> Ptr () -> IO ()

restarted

type C_MessageRestartedCallback = Ptr () -> Ptr () -> IO ()

type MessageRestartedCallback = IO ()

afterMessageRestarted :: (IsMessage a, MonadIO m) => a -> MessageRestartedCallback -> m SignalHandlerId

genClosure_MessageRestarted :: MessageRestartedCallback -> IO Closure

mk_MessageRestartedCallback :: C_MessageRestartedCallback -> IO (FunPtr C_MessageRestartedCallback)

noMessageRestartedCallback :: Maybe MessageRestartedCallback

onMessageRestarted :: (IsMessage a, MonadIO m) => a -> MessageRestartedCallback -> m SignalHandlerId

wrap_MessageRestartedCallback :: MessageRestartedCallback -> Ptr () -> Ptr () -> IO ()

starting

type C_MessageStartingCallback = Ptr () -> Ptr () -> IO ()

type MessageStartingCallback = IO ()

afterMessageStarting :: (IsMessage a, MonadIO m) => a -> MessageStartingCallback -> m SignalHandlerId

genClosure_MessageStarting :: MessageStartingCallback -> IO Closure

mk_MessageStartingCallback :: C_MessageStartingCallback -> IO (FunPtr C_MessageStartingCallback)

noMessageStartingCallback :: Maybe MessageStartingCallback

onMessageStarting :: (IsMessage a, MonadIO m) => a -> MessageStartingCallback -> m SignalHandlerId

wrap_MessageStartingCallback :: MessageStartingCallback -> Ptr () -> Ptr () -> IO ()

wroteBody

type C_MessageWroteBodyCallback = Ptr () -> Ptr () -> IO ()

type MessageWroteBodyCallback = IO ()

afterMessageWroteBody :: (IsMessage a, MonadIO m) => a -> MessageWroteBodyCallback -> m SignalHandlerId

genClosure_MessageWroteBody :: MessageWroteBodyCallback -> IO Closure

mk_MessageWroteBodyCallback :: C_MessageWroteBodyCallback -> IO (FunPtr C_MessageWroteBodyCallback)

noMessageWroteBodyCallback :: Maybe MessageWroteBodyCallback

onMessageWroteBody :: (IsMessage a, MonadIO m) => a -> MessageWroteBodyCallback -> m SignalHandlerId

wrap_MessageWroteBodyCallback :: MessageWroteBodyCallback -> Ptr () -> Ptr () -> IO ()

wroteBodyData

type C_MessageWroteBodyDataCallback = Ptr () -> Ptr Buffer -> Ptr () -> IO ()

type MessageWroteBodyDataCallback = Buffer -> IO ()

afterMessageWroteBodyData :: (IsMessage a, MonadIO m) => a -> MessageWroteBodyDataCallback -> m SignalHandlerId

genClosure_MessageWroteBodyData :: MessageWroteBodyDataCallback -> IO Closure

mk_MessageWroteBodyDataCallback :: C_MessageWroteBodyDataCallback -> IO (FunPtr C_MessageWroteBodyDataCallback)

noMessageWroteBodyDataCallback :: Maybe MessageWroteBodyDataCallback

onMessageWroteBodyData :: (IsMessage a, MonadIO m) => a -> MessageWroteBodyDataCallback -> m SignalHandlerId

wrap_MessageWroteBodyDataCallback :: MessageWroteBodyDataCallback -> Ptr () -> Ptr Buffer -> Ptr () -> IO ()

wroteChunk

type C_MessageWroteChunkCallback = Ptr () -> Ptr () -> IO ()

type MessageWroteChunkCallback = IO ()

afterMessageWroteChunk :: (IsMessage a, MonadIO m) => a -> MessageWroteChunkCallback -> m SignalHandlerId

genClosure_MessageWroteChunk :: MessageWroteChunkCallback -> IO Closure

mk_MessageWroteChunkCallback :: C_MessageWroteChunkCallback -> IO (FunPtr C_MessageWroteChunkCallback)

noMessageWroteChunkCallback :: Maybe MessageWroteChunkCallback

onMessageWroteChunk :: (IsMessage a, MonadIO m) => a -> MessageWroteChunkCallback -> m SignalHandlerId

wrap_MessageWroteChunkCallback :: MessageWroteChunkCallback -> Ptr () -> Ptr () -> IO ()

wroteHeaders

type C_MessageWroteHeadersCallback = Ptr () -> Ptr () -> IO ()

type MessageWroteHeadersCallback = IO ()

afterMessageWroteHeaders :: (IsMessage a, MonadIO m) => a -> MessageWroteHeadersCallback -> m SignalHandlerId

genClosure_MessageWroteHeaders :: MessageWroteHeadersCallback -> IO Closure

mk_MessageWroteHeadersCallback :: C_MessageWroteHeadersCallback -> IO (FunPtr C_MessageWroteHeadersCallback)

noMessageWroteHeadersCallback :: Maybe MessageWroteHeadersCallback

onMessageWroteHeaders :: (IsMessage a, MonadIO m) => a -> MessageWroteHeadersCallback -> m SignalHandlerId

wrap_MessageWroteHeadersCallback :: MessageWroteHeadersCallback -> Ptr () -> Ptr () -> IO ()

wroteInformational

type C_MessageWroteInformationalCallback = Ptr () -> Ptr () -> IO ()

type MessageWroteInformationalCallback = IO ()

afterMessageWroteInformational :: (IsMessage a, MonadIO m) => a -> MessageWroteInformationalCallback -> m SignalHandlerId

genClosure_MessageWroteInformational :: MessageWroteInformationalCallback -> IO Closure

mk_MessageWroteInformationalCallback :: C_MessageWroteInformationalCallback -> IO (FunPtr C_MessageWroteInformationalCallback)

noMessageWroteInformationalCallback :: Maybe MessageWroteInformationalCallback

onMessageWroteInformational :: (IsMessage a, MonadIO m) => a -> MessageWroteInformationalCallback -> m SignalHandlerId

wrap_MessageWroteInformationalCallback :: MessageWroteInformationalCallback -> Ptr () -> Ptr () -> IO ()