## SoupMessage

SoupMessage — An HTTP request and response.

## Synopsis

    struct      SoupMessage;
    enum        SoupMessageStatus;
    #define     SOUP_MESSAGE_IS_STARTING        (msg)
    enum        SoupTransferEncoding;
    enum        SoupOwnership;
                SoupDataBuffer;
    void        (*SoupMessageCallbackFn)        (SoupMessage *req,
                                                 gpointer user_data);

    SoupMessage* soup_message_new               (const char *method,
                                                 const char *uri_string);
    SoupMessage* soup_message_new_from_uri      (const char *method,
                                                 const SoupUri *uri);
    void        soup_message_set_request        (SoupMessage *msg,
                                                 const char *content_type,
                                                 SoupOwnership req_owner,
                                                 char *req_body,
                                                 gulong req_length);
    void        soup_message_set_response       (SoupMessage *msg,
                                                 const char *content_type,
                                                 SoupOwnership resp_owner,
                                                 char *resp_body,
                                                 gulong resp_length);

    void        soup_message_add_header         (GHashTable *hash,
                                                 const char *name,
                                                 const char *value);
    const char* soup_message_get_header         (GHashTable *hash,
                                                 const char *name);
    const GSList* soup_message_get_header_list  (GHashTable *hash,
                                                 const char *name);
    void        soup_message_foreach_header     (GHashTable *hash,
                                                 GHFunc func,
                                                 gpointer user_data);
    void        soup_message_remove_header      (GHashTable *hash,
                                                 const char *name);
    void        soup_message_clear_headers      (GHashTable *hash);

    enum        SoupHttpVersion;
    void        soup_message_set_http_version   (SoupMessage *msg,
                                                 SoupHttpVersion version);
    SoupHttpVersion soup_message_get_http_version
                                                (SoupMessage *msg);
    const SoupUri* soup_message_get_uri         (SoupMessage *msg);
    void        soup_message_set_uri            (SoupMessage *msg,
                                                 const SoupUri *uri);
    enum        SoupMessageFlags;
    void        soup_message_set_flags          (SoupMessage *msg,
                                                 guint flags);
    guint       soup_message_get_flags          (SoupMessage *msg);

    void        soup_message_set_status         (SoupMessage *msg,
                                                 guint status_code);
    void        soup_message_set_status_full    (SoupMessage *msg,
                                                 guint status_code,
                                                 const char *reason_phrase);
    void        soup_message_add_chunk          (SoupMessage *msg,
                                                 SoupOwnership owner,
                                                 const char *body,
                                                 guint length);
    void        soup_message_add_final_chunk    (SoupMessage *msg);
    SoupDataBuffer* soup_message_pop_chunk      (SoupMessage *msg);
    gboolean    soup_message_is_keepalive       (SoupMessage *msg);
    SoupTransferEncoding soup_message_get_request_encoding
                                                (SoupMessage *msg,
                                                 guint *content_length);
    SoupTransferEncoding soup_message_get_response_encoding
                                                (SoupMessage *msg,
                                                 guint *content_length);

    enum        SoupHandlerPhase;
    void        soup_message_add_handler        (SoupMessage *msg,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);
    void        soup_message_add_header_handler (SoupMessage *msg,
                                                 const char *header,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);
    void        soup_message_add_status_code_handler
                                                (SoupMessage *msg,
                                                 guint status_code,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);
    void        soup_message_add_status_class_handler
                                                (SoupMessage *msg,
                                                 SoupStatusClass status_class,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);
    void        soup_message_remove_handler     (SoupMessage *msg,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);

    void        soup_message_send_request       (SoupMessage *req,
                                                 SoupSocket *sock,
                                                 gboolean is_via_proxy);
    void        soup_message_read_request       (SoupMessage *req,
                                                 SoupSocket *sock);
    void        soup_message_io_pause           (SoupMessage *msg);
    void        soup_message_io_unpause         (SoupMessage *msg);
    void        soup_message_io_stop            (SoupMessage *msg);

## Object Hierarchy

      GObject
       +----SoupMessage
             +----SoupServerMessage
             +----SoupSoapMessage
             +----SoupXmlrpcMessage

## Signals

    "finished"  void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "got-body"  void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "got-chunk" void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "got-headers"
                void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "got-informational"
                void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "restarted" void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "wrote-body"
                void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "wrote-chunk"
                void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "wrote-headers"
                void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first
    "wrote-informational"
                void        user_function      (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

## Description

## Details

### struct SoupMessage

    struct SoupMessage {
    	const char         *method;

    	guint               status_code;
    	const char         *reason_phrase;

    	SoupDataBuffer      request;
    	GHashTable         *request_headers;

    	SoupDataBuffer      response;
    	GHashTable         *response_headers;

    	SoupMessageStatus   status;
    };

Represents an HTTP message being sent or received.

const char *`method`; | the HTTP method
guint `status_code`; | the HTTP status code
const char *`reason_phrase`; | the status phrase associated with `status_code`
SoupDataBuffer `request`; | the request buffer
GHashTable *`request_headers`; | the request headers
SoupDataBuffer `response`; | the response buffer
GHashTable *`response_headers`; | the response headers
SoupMessageStatus `status`; | the processing status of the message

### enum SoupMessageStatus

    typedef enum {
    	SOUP_MESSAGE_STATUS_IDLE,
    	SOUP_MESSAGE_STATUS_QUEUED,
            SOUP_MESSAGE_STATUS_CONNECTING,
            SOUP_MESSAGE_STATUS_RUNNING,
    	SOUP_MESSAGE_STATUS_FINISHED
    } SoupMessageStatus;

Enum indicating the lifecycle of a SoupMessage.

`SOUP_MESSAGE_STATUS_IDLE` | The message has not yet been queued.
`SOUP_MESSAGE_STATUS_QUEUED` | The message has been queued, but is waiting for a connection to be available.
`SOUP_MESSAGE_STATUS_CONNECTING` | The message is waiting for a specific connection to finish connecting.
`SOUP_MESSAGE_STATUS_RUNNING` | The message is being processed.
`SOUP_MESSAGE_STATUS_FINISHED` | The message is complete (request and response both processed).

### SOUP_MESSAGE_IS_STARTING()

    #define SOUP_MESSAGE_IS_STARTING(msg) (msg->status == SOUP_MESSAGE_STATUS_QUEUED || msg->status == SOUP_MESSAGE_STATUS_CONNECTING)

Tests if `msg` is in a "starting" state, waiting to be sent. (More commonly used to test if a message has been requeued after its first attempt.)

`msg` : | a SoupMessage
Returns : | `TRUE` if `msg` is waiting to be sent.

### enum SoupTransferEncoding

    typedef enum {
    	SOUP_TRANSFER_UNKNOWN = 0,
    	SOUP_TRANSFER_CHUNKED,
    	SOUP_TRANSFER_CONTENT_LENGTH,
    	SOUP_TRANSFER_BYTERANGES,
    	SOUP_TRANSFER_NONE,
    	SOUP_TRANSFER_EOF
    } SoupTransferEncoding;

How the length of a request or response is to be encoded.

`SOUP_TRANSFER_UNKNOWN` | unknown / error
`SOUP_TRANSFER_CHUNKED` | chunked encoding (currently only supported for response)
`SOUP_TRANSFER_CONTENT_LENGTH` | Content-Length encoding
`SOUP_TRANSFER_BYTERANGES` | multipart/byteranges (Reserved for future use: NOT CURRENTLY IMPLEMENTED)
`SOUP_TRANSFER_NONE` | no body is present (which is not the same as a 0-length body, and only occurs in certain places)
`SOUP_TRANSFER_EOF` | Response body ends when the connection is closed

### enum SoupOwnership

    typedef enum {
    	SOUP_BUFFER_SYSTEM_OWNED = 0,
    	SOUP_BUFFER_USER_OWNED,
    	SOUP_BUFFER_STATIC
    } SoupOwnership;

Used by SoupDataBuffer (and several functions) to indicate the ownership of a buffer.

`SOUP_BUFFER_SYSTEM_OWNED` | The data is owned by soup and it can free it when it is done with it.
`SOUP_BUFFER_USER_OWNED` | The data is owned by the user, who is responsible for freeing it at the right point
`SOUP_BUFFER_STATIC` | The data should not be freed.

### SoupDataBuffer

    typedef struct {
    	SoupOwnership  owner;
    	char          *body;
    	guint          length;
    } SoupDataBuffer;

A data buffer used in several places.

SoupOwnership `owner`; | the ownership of the data
char *`body`; | the data itself
guint `length`; | length of `body`

### SoupMessageCallbackFn ()

    void        (*SoupMessageCallbackFn)        (SoupMessage *req,
                                                 gpointer user_data);

A callback function used by many SoupMessage methods.

`req` : | the SoupMessage in question
`user_data` : | user data

### soup_message_new ()

    SoupMessage* soup_message_new               (const char *method,
                                                 const char *uri_string);

Creates a new empty SoupMessage, which will connect to `uri`

`method` : | the HTTP method for the created request
`uri_string` : | the destination endpoint (as a string)
Returns : | the new SoupMessage (or `NULL` if `uri` could not be parsed).

### soup_message_new_from_uri ()

    SoupMessage* soup_message_new_from_uri      (const char *method,
                                                 const SoupUri *uri);

Creates a new empty SoupMessage, which will connect to `uri`

`method` : | the HTTP method for the created request
`uri` : | the destination endpoint (as a SoupUri)
Returns : | the new SoupMessage

### soup_message_set_request ()

    void        soup_message_set_request        (SoupMessage *msg,
                                                 const char *content_type,
                                                 SoupOwnership req_owner,
                                                 char *req_body,
                                                 gulong req_length);

Convenience function to set the request body of a SoupMessage

`msg` : | the message
`content_type` : | MIME Content-Type of the body
`req_owner` : | the SoupOwnership of the passed data buffer.
`req_body` : | a data buffer containing the body of the message request.
`req_length` : | the byte length of `req_body`.

### soup_message_set_response ()

    void        soup_message_set_response       (SoupMessage *msg,
                                                 const char *content_type,
                                                 SoupOwnership resp_owner,
                                                 char *resp_body,
                                                 gulong resp_length);

Convenience function to set the response body of a SoupMessage

`msg` : | the message
`content_type` : | MIME Content-Type of the body
`resp_owner` : | the SoupOwnership of the passed data buffer.
`resp_body` : | a data buffer containing the body of the message response.
`resp_length` : | the byte length of `resp_body`.

### soup_message_add_header ()

    void        soup_message_add_header         (GHashTable *hash,
                                                 const char *name,
                                                 const char *value);

Adds a header with name `name` and value `value` to `hash`. If there was already a header with name `name`, this one does not replace it, it is merely added to it.

`hash` : | a header table (the `request_headers` or `response_headers` field of a SoupMessage)
`name` : | the header name to add
`value` : | the value of the new header

### soup_message_get_header ()

    const char* soup_message_get_header         (GHashTable *hash,
                                                 const char *name);

Finds the first header in `hash` with name `name`.

`hash` : | a header table (the `request_headers` or `response_headers` field of a SoupMessage)
`name` : | header name.
Returns : | the header's value or `NULL` if not found.

### soup_message_get_header_list ()

    const GSList* soup_message_get_header_list  (GHashTable *hash,
                                                 const char *name);

Finds all headers in `hash` with name `name`.

`hash` : | a header table (the `request_headers` or `response_headers` field of a SoupMessage)
`name` : | header name.
Returns : | a (possibly empty) list of values of headers with name `name`. The caller should not modify or free this list.

### soup_message_foreach_header ()

    void        soup_message_foreach_header     (GHashTable *hash,
                                                 GHFunc func,
                                                 gpointer user_data);

Calls `func` once for each header value in `hash`. (If there are headers will multiple values, `func` will be called once on each value.)

`hash` : | a header table (the `request_headers` or `response_headers` field of a SoupMessage)
`func` : | callback function to run for each header
`user_data` : | data to pass to `func`

### soup_message_remove_header ()

    void        soup_message_remove_header      (GHashTable *hash,
                                                 const char *name);

Removes `name` from `hash`. If there are multiple values for `name`, they are all removed.

`hash` : | a header table (the `request_headers` or `response_headers` field of a SoupMessage)
`name` : | the header name to remove

### soup_message_clear_headers ()

    void        soup_message_clear_headers      (GHashTable *hash);

Clears `hash`.

`hash` : | a header table (the `request_headers` or `response_headers` field of a SoupMessage)

### enum SoupHttpVersion

    typedef enum {
    	SOUP_HTTP_1_0 = 0,
    	SOUP_HTTP_1_1 = 1
    } SoupHttpVersion;

Indicates the HTTP protocol version being used.

`SOUP_HTTP_1_0` | HTTP 1.0 (RFC 1945)
`SOUP_HTTP_1_1` | HTTP 1.1 (RFC 2616)

### soup_message_set_http_version ()

    void        soup_message_set_http_version   (SoupMessage *msg,
                                                 SoupHttpVersion version);

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

`msg` : | a SoupMessage
`version` : | the HTTP version

### soup_message_get_http_version ()

    SoupHttpVersion soup_message_get_http_version
                                                (SoupMessage *msg);

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

`msg` : | a SoupMessage
Returns : | the HTTP version

### soup_message_get_uri ()

    const SoupUri* soup_message_get_uri         (SoupMessage *msg);

Gets `msg`'s URI

`msg` : | a SoupMessage
Returns : | the URI `msg` is targeted for.

### soup_message_set_uri ()

    void        soup_message_set_uri            (SoupMessage *msg,
                                                 const SoupUri *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 `soup_session_requeue_message()`.

`msg` : | a SoupMessage
`uri` : | the new SoupUri

### enum SoupMessageFlags

    typedef enum {
    	SOUP_MESSAGE_NO_REDIRECT      = (1 << 1),
    	SOUP_MESSAGE_OVERWRITE_CHUNKS = (1 << 3),
    	SOUP_MESSAGE_EXPECT_CONTINUE  = (1 << 4)
    } SoupMessageFlags;

Various flags that can be set on a SoupMessage to alter its behavior.

`SOUP_MESSAGE_NO_REDIRECT` | The session should not follow redirect (3xx) responses received by this message.
`SOUP_MESSAGE_OVERWRITE_CHUNKS` | Rather than building up the response body in `response`, each new chunk should overwrite the previous one. (This can be used if you are connecting to the `got_chunk` signal or have installed a `SOUP_MESSAGE_BODY_CHUNK` handler.
`SOUP_MESSAGE_EXPECT_CONTINUE` | This will cause an "Expect: 100-continue" header to be added to the outgoing request, giving the server the opportunity to reject the message (eg, with a 401 Unauthorized) before the full request body is sent.

### soup_message_set_flags ()

    void        soup_message_set_flags          (SoupMessage *msg,
                                                 guint flags);

Sets the specified flags on `msg`.

`msg` : | a SoupMessage
`flags` : | a set of SoupMessageFlags values

### soup_message_get_flags ()

    guint       soup_message_get_flags          (SoupMessage *msg);

Gets the flags on `msg`

`msg` : | a SoupMessage
Returns : | the flags

### soup_message_set_status ()

    void        soup_message_set_status         (SoupMessage *msg,
                                                 guint 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.

`msg` : | a SoupMessage
`status_code` : | an HTTP status code

### soup_message_set_status_full ()

    void        soup_message_set_status_full    (SoupMessage *msg,
                                                 guint status_code,
                                                 const char *reason_phrase);

Sets `msg`'s status code and reason phrase.

`msg` : | a SoupMessage
`status_code` : | an HTTP status code
`reason_phrase` : | a description of the status

### soup_message_add_chunk ()

    void        soup_message_add_chunk          (SoupMessage *msg,
                                                 SoupOwnership owner,
                                                 const char *body,
                                                 guint length);

Adds a chunk of response data to `body`. (Note that currently there is no way to send a request using chunked encoding.)

`msg` : | a SoupMessage
`owner` : | the ownership of `body`
`body` : | body data
`length` : | length of `body`

### soup_message_add_final_chunk ()

    void        soup_message_add_final_chunk    (SoupMessage *msg);

Adds a final, empty chunk of response data to `body`. This must be called after adding the last real chunk, to indicate that there is no more data.

`msg` : | a SoupMessage

### soup_message_pop_chunk ()

    SoupDataBuffer* soup_message_pop_chunk      (SoupMessage *msg);

Pops a chunk of response data from `msg`'s chunk list. The caller must free `chunk` itself, and must handle the data in `chunk` according to its `ownership`.

`msg` : | a SoupMessage
Returns : | the chunk, or `NULL` if there are no chunks left.

### soup_message_is_keepalive ()

    gboolean    soup_message_is_keepalive       (SoupMessage *msg);

Determines whether or not `msg`'s connection can be kept alive for further requests after processing `msg`.

`msg` : | a SoupMessage
Returns : | `TRUE` or `FALSE`.

### soup_message_get_request_encoding ()

    SoupTransferEncoding soup_message_get_request_encoding
                                                (SoupMessage *msg,
                                                 guint *content_length);

Gets `msg`'s request encoding. For an outgoing (client) request, this is only valid after the message has been fully set up (from the library's perspective, that means not until the message has been queued). For an incoming (server) request, this is valid after the request headers have been read and `msg->request_headers` filled in.

`msg` : | a SoupMessage
`content_length` : | a pointer to store the Content-Length in (or `NULL`).
Returns : | the request encoding (which cannot be `SOUP_TRANSFER_UNKNOWN` or `SOUP_TRANSFER_EOF`). If it is `SOUP_TRANSFER_CONTENT_LENGTH`, *`content_length` will be set to the request body's length.

### soup_message_get_response_encoding ()

    SoupTransferEncoding soup_message_get_response_encoding
                                                (SoupMessage *msg,
                                                 guint *content_length);

Gets `msg`'s response encoding. For an outgoing (client) request, this is only valid after the response headers have been read and `msg->response_headers` filled in. For an incoming (server) request, this is valid after the server handler has run.

Note that the returned value is the encoding actually used on the wire; this will not agree with the response headers in some cases (eg, a HEAD response may have a Content-Length header, but will still be considered `SOUP_TRANSFER_NONE` by this function).

`msg` : | a SoupMessage
`content_length` : | a pointer to store the Content-Length in (or `NULL`).
Returns : | the response encoding (which will not be `SOUP_TRANSFER_UNKNOWN`). If it is `SOUP_TRANSFER_CONTENT_LENGTH`, *`content_length` will be set to the response body's length.

### enum SoupHandlerPhase

    typedef enum {
    	SOUP_HANDLER_POST_REQUEST = 1,
    	SOUP_HANDLER_PRE_BODY,
    	SOUP_HANDLER_BODY_CHUNK,
    	SOUP_HANDLER_POST_BODY
    } SoupHandlerPhase;

Indicates when a handler added with `soup_message_add_handler()` or the like will be run.

`SOUP_HANDLER_POST_REQUEST` | The handler should run immediately after sending the request body
`SOUP_HANDLER_PRE_BODY` | The handler should run before reading the response body (after reading the headers).
`SOUP_HANDLER_BODY_CHUNK` | The handler should run after every body chunk is read. (See also `SOUP_MESSAGE_OVERWRITE_CHUNKS`.)
`SOUP_HANDLER_POST_BODY` | The handler should run after the entire message body has been read.

### soup_message_add_handler ()

    void        soup_message_add_handler        (SoupMessage *msg,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);

Adds a handler to `msg` for all messages

`msg` : | a SoupMessage
`phase` : | processing phase to run the handler in
`handler_cb` : | the handler
`user_data` : | data to pass to `handler_cb`

### soup_message_add_header_handler ()

    void        soup_message_add_header_handler (SoupMessage *msg,
                                                 const char *header,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);

Adds a handler to `msg` for messages containing the given response header.

`msg` : | a SoupMessage
`header` : | HTTP response header to match against
`phase` : | processing phase to run the handler in
`handler_cb` : | the handler
`user_data` : | data to pass to `handler_cb`

### soup_message_add_status_code_handler ()

    void        soup_message_add_status_code_handler
                                                (SoupMessage *msg,
                                                 guint status_code,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);

Adds a handler to `msg` for messages receiving the given status code.

`msg` : | a SoupMessage
`status_code` : | HTTP status code to match against
`phase` : | processing phase to run the handler in
`handler_cb` : | the handler
`user_data` : | data to pass to `handler_cb`

### soup_message_add_status_class_handler ()

    void        soup_message_add_status_class_handler
                                                (SoupMessage *msg,
                                                 SoupStatusClass status_class,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);

Adds a handler to `msg` for messages receiving a status code in the given class.

`msg` : | a SoupMessage
`status_class` : | HTTP status code class to match against
`phase` : | processing phase to run the handler in
`handler_cb` : | the handler
`user_data` : | data to pass to `handler_cb`

### soup_message_remove_handler ()

    void        soup_message_remove_handler     (SoupMessage *msg,
                                                 SoupHandlerPhase phase,
                                                 SoupMessageCallbackFn handler_cb,
                                                 gpointer user_data);

Removes all matching handlers from `msg`

`msg` : | a SoupMessage
`phase` : | processing phase to run the handler in
`handler_cb` : | the handler
`user_data` : | data to pass to `handler_cb`

### soup_message_send_request ()

    void        soup_message_send_request       (SoupMessage *req,
                                                 SoupSocket *sock,
                                                 gboolean is_via_proxy);

Begins the process of sending `msg` across `sock`. (If `sock` is synchronous, then `soup_message_send_request()` won't return until the response has been received.)

`req` : | a SoupMessage
`sock` : | the SoupSocket to send `req` on
`is_via_proxy` : | `TRUE` if `sock` is a connection to a proxy server rather than a direct connection to the desired HTTP server

### soup_message_read_request ()

    void        soup_message_read_request       (SoupMessage *req,
                                                 SoupSocket *sock);

Begins the process of receiving a request from `sock` into `req`.

`req` : | an empty SoupServerMessage
`sock` : | socket to receive the request on

### soup_message_io_pause ()

    void        soup_message_io_pause           (SoupMessage *msg);

Pauses I/O on `msg`.

`msg` : | a SoupMessage

### soup_message_io_unpause ()

    void        soup_message_io_unpause         (SoupMessage *msg);

Resumes I/O on `msg`.

`msg` : | a SoupMessage

### soup_message_io_stop ()

    void        soup_message_io_stop            (SoupMessage *msg);

Immediately stops I/O on msg; if the connection would be left in an inconsistent state, it will be closed.

Note: this is a low-level function that does not cause any signals to be emitted on `msg`; it is up to the caller to make sure that `msg` doesn't get "stranded".

`msg` : | a SoupMessage

## Signal Details

### The "finished" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

Emitted when all HTTP processing is finished for a message. (After read-body for client-side code, or after wrote-body for server-side code.)

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "got-body" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

Emitted after receiving the complete message body.

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "got-chunk" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

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.

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "got-headers" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

Emitted after receiving all message headers for a message.

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "got-informational" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

Emitted after receiving a 1xx (Informational) response for a message.

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "restarted" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

Emitted when a message is about to be re-queued.

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "wrote-body" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

Emitted immediately after writing the complete body for a message.

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "wrote-chunk" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

Emitted immediately after writing a body chunk for a message. (This is

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "wrote-headers" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

Emitted immediately after writing the headers for a message.

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.

### The "wrote-informational" signal

    void        user_function                  (SoupMessage *msg,
                                                gpointer     user_data)      : Run first

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

`msg` : | the message
`user_data` : | user data set when the signal handler was connected.