Creates a new #SoupMessageBody. #SoupMessage uses this internally; you will not normally need to call it yourself.
the data
length of data
Appends length bytes from data to body.
This function is exactly equivalent to soup_message_body_append() with %SOUP_MEMORY_TAKE as second argument; it exists mainly for convenience and simplifying language bindings.
data to append
Tags body as being complete; Call this when using chunked encoding
after you have appended the last chunk.
Frees body. You will not normally need to use this, as
#SoupMessage frees its associated message bodies automatically.
Gets the accumulate flag on body; see
soup_message_body_set_accumulate() for details.
Gets a #SoupBuffer containing data from body starting at offset.
The size of the returned chunk is unspecified. You can iterate
through the entire body by first calling
soup_message_body_get_chunk() with an offset of 0, and then on each
successive call, increment the offset by the length of the
previously-returned chunk.
If offset is greater than or equal to the total length of body,
then the return value depends on whether or not
soup_message_body_complete() has been called or not; if it has,
then soup_message_body_get_chunk() will return a 0-length chunk
(indicating the end of body). If it has not, then
soup_message_body_get_chunk() will return %NULL (indicating that
body may still potentially have more data, but that data is not
currently available).
an offset
Handles the #SoupMessageBody part of receiving a chunk of data from
the network. Normally this means appending chunk to body, exactly
as with soup_message_body_append_buffer(), but if you have set
body's accumulate flag to %FALSE, then that will not happen.
This is a low-level method which you should not normally need to use.
Sets or clears the accumulate flag on body. (The default value is
%TRUE.) If set to %FALSE, body's %data field will not be filled in
after the body is fully sent/received, and the chunks that make up
body may be discarded when they are no longer needed.
In particular, if you set this flag to %FALSE on an "incoming" message body (that is, the #SoupMessage:response_body of a client-side message, or #SoupMessage:request_body of a server-side message), this will cause each chunk of the body to be discarded after its corresponding #SoupMessage::got_chunk signal is emitted. (This is equivalent to setting the deprecated %SOUP_MESSAGE_OVERWRITE_CHUNKS flag on the message.)
If you set this flag to %FALSE on the #SoupMessage:response_body of a server-side message, it will cause each chunk of the body to be discarded after its corresponding #SoupMessage::wrote_chunk signal is emitted.
If you set the flag to %FALSE on the #SoupMessage:request_body of a
client-side message, it will block the accumulation of chunks into
body's %data field, but it will not normally cause the chunks to
be discarded after being written like in the server-side
#SoupMessage:response_body case, because the request body needs to
be kept around in case the request needs to be sent a second time
due to redirection or authentication. However, if you set the
%SOUP_MESSAGE_CAN_REBUILD flag on the message, then the chunks will
be discarded, and you will be responsible for recreating the
request body after the #SoupMessage::restarted signal is emitted.
whether or not to accumulate body chunks in body
Deletes all of the data in body.
Handles the #SoupMessageBody part of writing a chunk of data to the
network. Normally this is a no-op, but if you have set body's
accumulate flag to %FALSE, then this will cause chunk to be
discarded to free up memory.
This is a low-level method which you should not need to use, and there are further restrictions on its proper use which are not documented here.
Creates a new #SoupMessageBody. #SoupMessage uses this internally; you will not normally need to call it yourself.
A #SoupMessage request or response body.
Note that while
lengthalways reflects the full length of the message body,datais normally %NULL, and will only be filled in after soup_message_body_flatten() is called. For client-side messages, this automatically happens for the response body after it has been fully read, unless you set the %SOUP_MESSAGE_OVERWRITE_CHUNKS flags. Likewise, for server-side messages, the request body is automatically filled in after being read.As an added bonus, when
datais filled in, it is always terminated with a '\0' byte (which is not reflected inlength).