Memory-managed wrapper type.

Type class for types which can be safely cast to ServerMessage, for instance with toServerMessage.

Cast to ServerMessage, for types for which this is known to be safe. For general casts, use castTo.

Get the HTTP version of msg.

Retrieves the SocketAddress associated with the local end of a connection.

Get the HTTP method of msg.

Get the HTTP reason phrase of msg.

Retrieves the SocketAddress associated with the remote end of a connection.

Retrieves the IP address associated with the remote end of a connection.

Get the request body of msg.

Get the request headers of msg.

Get the response body of msg.

Get the response headers of msg.

Retrieves the Socket that msg is associated with.

If you are using this method to observe when multiple requests are made on the same persistent HTTP connection (eg, as the ntlm-test test program does), you will need to pay attention to socket destruction as well (eg, by using weak references), so that you do not get fooled when the allocator reuses the memory address of a previously-destroyed socket to represent a new socket.

Get the HTTP status code of msg.

Gets the peer's TlsCertificate associated with msg's connection. Note that this is not set yet during the emission of SoupServerMessageacceptCertificate signal.

Since: 3.2

Gets the errors associated with validating msg's TLS peer certificate. Note that this is not set yet during the emission of SoupServerMessageacceptCertificate signal.

Since: 3.2

Get msg's URI.

Gets if msg represents an OPTIONS message with the path *.

Pauses I/O on msg.

This can be used when you need to return from the server handler without having the full response ready yet. Use [methodserverMessage.unpause] to resume I/O.

Since: 3.2

Set the HTTP version of msg.

Sets msg's status_code to statusCode and adds a Location header pointing to redirectUri. Use this from a [classserver] 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 *and query* of msg's URI.

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

Sets msg's status code to statusCode.

If statusCode is a known value and reasonPhrase is Nothing, the reason_phrase will be set automatically.

"Steals" the HTTP connection associated with msg from its Server. This happens immediately, regardless of the current state of the connection; if the response to msg has not yet finished being sent, then it will be discarded; you can steal the connection from a signalserverMessage[wroteInformational] or signalserverMessage[wroteBody] signal handler if you need to wait for part or all of the response to be sent.

Note that when calling this function from C, msg will most likely be freed as a side effect.

Resumes I/O on msg.

Use this to resume after calling [methodserverMessage.pause], or after adding a new chunk to a chunked response. I/O won't actually resume until you return to the main loop.

Since: 3.2

Get the value of the “tls-peer-certificate” property. When overloading is enabled, this is equivalent to

get serverMessage #tlsPeerCertificate

Get the value of the “tls-peer-certificate-errors” property. When overloading is enabled, this is equivalent to

get serverMessage #tlsPeerCertificateErrors

Emitted during the msg's connection TLS handshake after client TLS certificate has been received. You can return True to accept tlsCertificate despite tlsErrors.

Connect a signal handler for the acceptCertificate signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #acceptCertificate callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the acceptCertificate signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #acceptCertificate callback

Emitted when the msg's socket is connected and the TLS handshake completed.

Connect a signal handler for the connected signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #connected callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the connected signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #connected callback

Emitted when the msg's socket is disconnected.

Connect a signal handler for the disconnected signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #disconnected callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the disconnected signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #disconnected callback

Emitted when all HTTP processing is finished for a message. (After signalserverMessage[wroteBody]).

Connect a signal handler for the finished signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #finished callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the finished signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #finished callback

Emitted after receiving the complete request body.

Connect a signal handler for the gotBody signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #gotBody callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the gotBody signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #gotBody callback

Emitted after receiving a chunk of a message body.

Note that "chunk" in this context means any subpiece of the body, not necessarily the specific HTTP 1.1 chunks sent by the other side.

Connect a signal handler for the gotChunk signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #gotChunk callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the gotChunk signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #gotChunk callback

Emitted after receiving the Request-Line and request headers.

Connect a signal handler for the gotHeaders signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #gotHeaders callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the gotHeaders signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #gotHeaders callback

Emitted immediately after writing the complete response body for a message.

Connect a signal handler for the wroteBody signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #wroteBody callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the wroteBody signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #wroteBody callback

Emitted immediately after writing a portion of the message body to the network.

Connect a signal handler for the wroteBodyData signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #wroteBodyData callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the wroteBodyData signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #wroteBodyData callback

Emitted immediately after writing a body chunk for a message.

Note that this signal is not parallel to signalserverMessage[gotChunk]; it is emitted only when a complete chunk (added with [methodmessageBody.append] or [methodmessageBody.append_bytes] has been written. To get more useful continuous progress information, use signalserverMessage[wroteBodyData].

Connect a signal handler for the wroteChunk signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #wroteChunk callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the wroteChunk signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #wroteChunk callback

Emitted immediately after writing the response headers for a message.

Connect a signal handler for the wroteHeaders signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #wroteHeaders callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the wroteHeaders signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #wroteHeaders callback

Emitted immediately after writing a 1xx (Informational) response.

Connect a signal handler for the wroteInformational signal, to be run after the default handler. When overloading is enabled, this is equivalent to

after serverMessage #wroteInformational callback

By default the object invoking the signal is not passed to the callback. If you need to access it, you can use the implit ?self parameter. Note that this requires activating the ImplicitParams GHC extension.

Connect a signal handler for the wroteInformational signal, to be run before the default handler. When overloading is enabled, this is equivalent to

on serverMessage #wroteInformational callback