Message

Message

Object Hierarchy:

Description:

public class Message : Object

Represents an HTTP message being sent or received.

status_code will normally be a KnownStatusCode, eg, OK, though of course it might actually be an unknown status code. reason_phrase is the actual text returned from the server, which may or may not correspond to the "standard" description of status_code. 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 reason_phrase in user-visible messages. Rather, you should look at status_code, 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 request_body and response_body data fields will not necessarily be filled in at all times. When they are filled in, they will be terminated with a '\0' byte (which is not included in the length), 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, request_body's data is usually filled in right before libsoup writes the request to the network, but you should not count on this; use flatten if you want to ensure that data is filled in. response_body's data will be filled in before finished is emitted.

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

To prevent the data field from being filled in at all (eg, if you are handling the data from a got_chunk, and so don't need to see it all at the end), call set_accumulate on response_body or request_body as appropriate, passing false.

Namespace: Soup

Package: libsoup-2.4

Content:

Properties:

public URI first_party { set; get; }
The URI loaded in the application when the message was queued.
public MessageFlags flags { set; get; }
public HTTPVersion http_version { set; get; }
public string method { set; owned get; }
public string reason_phrase { set; owned get; }
public bool server_side { construct set; get; }
public uint status_code { set; get; }
public URI uri { set; get; }

Creation methods:

public Message (string method, string uri_string)
Creates a new empty Message, which will connect to uri
public Message.from_uri (string method, URI uri)
Creates a new empty Message, which will connect to uri

Methods:

public uint add_header_handler (string signal, string header, Callback callback)
Adds a signal handler to msg for signal, as with connect, but with two differences: the callback will only be run if msg has a header named header, and it will only be run if no earlier handler cancelled or requeued the message.
public uint add_status_code_handler (string signal, uint status_code, Callback callback)
Adds a signal handler to msg for signal, as with connect but with two differences: the callback will only be run if msg has the status status_code, and it will only be run if no earlier handler cancelled or requeued the message.
public void disable_feature (Type feature_type)
This disables the actions of SessionFeatures with the given feature_type (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_PROXY_URI_RESOLVER for feature_type will disable proxy handling and cause msg to be sent directly to the indicated origin server, regardless of system proxy configuration.
public weak Address get_address ()
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.
public unowned URI get_first_party ()
Gets msg's first-party URI
public MessageFlags get_flags ()
Gets the flags on msg
public HTTPVersion get_http_version ()
Gets the HTTP version of msg. This is the minimum of the version from the request and the version from the response.
public unowned URI get_uri ()
Gets msg's URI
public bool is_keepalive ()
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.
public void set_chunk_allocator (owned ChunkAllocator allocator)
Sets an alternate chunk-allocation function to use when reading msg's body. 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 length to indicate how much data it read.
public void set_first_party (URI first_party)
Sets first_party as the main document URI for msg. For details of when and how this is used refer to the documentation for CookieJarAcceptPolicy.
public void set_flags (MessageFlags flags)
Sets the specified flags on msg.
public void set_http_version (HTTPVersion version)
Sets the HTTP version on msg. The default version is 1_1. Setting it to 1_0 will prevent certain functionality from being used.
public void set_request (string content_type, MemoryUse req_use, uint8[] req_body)
Convenience function to set the request body of a Message. If content_type is null, the request body must be empty as well.
public void set_response (string? content_type, MemoryUse resp_use, uint8[] resp_body)
Convenience function to set the response body of a Message . If content_type is null, the response body must be empty as well.
public void set_status (uint status_code)
Sets msg's status code to status_code. If status_code is a known value, it will also set msg's reason_phrase.
public void set_status_full (uint status_code, string reason_phrase)
Sets msg's status code and reason phrase.
public void set_uri (URI uri)
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 requeue_message .

Signals:

public void content_sniffed (string object, HashTable<void*,void*> p0)
This signal is emitted after got_headers, and before the first got_chunk. If content sniffing is disabled, or no content sniffing will be performed, due to the sniffer deciding to trust the Content-Type sent by the server, this signal is emitted immediately after got_headers, and type is null.
public virtual void finished ()
Emitted when all HTTP processing is finished for a message. (After got_body for client-side messages, or after wrote_body for server-side messages.)
public virtual void got_body ()
Emitted after receiving the complete message body. (For a server-side message, this means it has received the request body. For a client-side message, this means it has received the response body and is nearly done with the message.)
public virtual void got_chunk (Buffer chunk)
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.
public virtual void got_headers ()
Emitted after receiving all message headers for a message. (For a client-side message, this is after receiving the Status-Line and response headers; for a server-side message, it is after receiving the Request-Line and request headers.)
public virtual void got_informational ()
Emitted after receiving a 1xx (Informational) response for a (client-side) message. The response_headers will be filled in with the headers associated with the informational response; however, those header values will be erased after this signal is done.
public virtual void restarted ()
Emitted when a request that was already sent once is now being sent again (eg, because the first attempt received a redirection response, or because we needed to use authentication).
public virtual void wrote_body ()
Emitted immediately after writing the complete body for a message. (For a client-side message, this means that libsoup is done writing and is now waiting for the response from the server. For a server-side message, this means that libsoup has finished writing the response and is nearly done with the message.)
public void wrote_body_data (Buffer object)
Emitted immediately after writing a portion of the message body to the network.
public virtual void wrote_chunk ()
Emitted immediately after writing a body chunk for a message.
public virtual void wrote_headers ()
Emitted immediately after writing the headers for a message. (For a client-side message, this is after writing the request headers; for a server-side message, it is after writing the response headers.)
public virtual void wrote_informational ()
Emitted immediately after writing a 1xx (Informational) response for a (server-side) message.

Fields:

public unowned MessageBody request_body
public unowned MessageHeaders request_headers
public unowned MessageBody response_body
public unowned MessageHeaders response_headers