Back to Seed Clases

Soup

Classes

Interfaces

Structs

Unions

Enums

GObject.Object
parent-child marker Soup.Message

Class Soup.Message

Import line:	Soup = imports.gi.Soup;
GIR File:	Soup-2.4.gir
C documentation:	SoupMessage
Class :	Message
Extends:	GObject.Object

Represents an HTTP message being sent or received.
SOUP_STATUS_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 SoupMessageBody documentation, the
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 SoupMessage, 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 soup_message_body_flatten()
if you want to ensure that data is filled in. response_body's
data will be filled in before SoupMessage::finished is emitted.
For a server-side SoupMessage, request_body's data will be
filled in before SoupMessage::got_body is emitted.
To prevent the data field from being filled in at all (eg, if you
are handling the data from a SoupMessage::got_chunk, and so don't
need to see it all at the end), call
soup_message_body_set_accumulate() on response_body or

Properties
Properties		Defined By
	first_party : Soup.URI	Soup.Message
	flags : Soup.MessageFlags	Soup.Message
	http_version : Soup.HTTPVersion	Soup.Message
	method : String	Soup.Message
	method : String read only	Soup.Message
	parent : GObject.Object read only	Soup.Message
	reason_phrase : String	Soup.Message
	reason_phrase : String read only	Soup.Message
	request_body : Soup.MessageBody read only	Soup.Message
	request_body : Soup.MessageBody read only	Soup.Message
	request_headers : Soup.MessageHeaders read only	Soup.Message
	request_headers : Soup.MessageHeaders read only	Soup.Message
	response_body : Soup.MessageBody read only	Soup.Message
	response_body : Soup.MessageBody read only	Soup.Message
	response_headers : Soup.MessageHeaders read only	Soup.Message
	response_headers : Soup.MessageHeaders read only	Soup.Message
	server_side : gboolean	Soup.Message
	status_code : guint32	Soup.Message
	status_code : guint32 read only	Soup.Message
	tls_certificate : Gio.TlsCertificate	Soup.Message
	tls_errors : Gio.TlsCertificateFlags	Soup.Message
	uri : Soup.URI	Soup.Message

Methods / Constructors
Method / Constructor		Defined By
	new Soup.Message (Object *properties) Create a new Soup.Message Create a new Soup.Message Parameters: Object properties*
	new Soup.Message.c_new (String *method, String uri_string) : Soup.Message Create a new Soup.Message Create a new Soup.Message Parameters: String method* Required (not null) the HTTP method for the created request String uri_string Required (not null) the destination endpoint (as a string) Returns: Soup.Message the new SoupMessage (or NULL if uri could not
	new Soup.Message.from_uri (String *method, URI uri) : Soup.Message Create a new Soup.Message Create a new Soup.Message Parameters: String method* Required (not null) the HTTP method for the created request Soup.URI uri Required (not null) the destination endpoint (as a SoupURI) Returns: Soup.Message the new SoupMessage
	content_sniffed (String *content_type, Object params) : none Emits the content_sniffed* signal, indicating that the IO layer finished sniffing the content type for msg. Emits the content_sniffed signal, indicating that the IO layer finished sniffing the content type for msg. If content sniffing will not be performed, due to the sniffer deciding to trust the Content-Type sent by the server, this signal is emitted immediately after got_headers, with NULL as content_type. Parameters: String content_type Required (not null) Object params Required (not null) a GHashTable with the parameters Returns: none	Soup.Message
	disable_feature (Number *feature_type) : none This disables the actions of SoupSessionFeatures with the given feature_type* (or a subclass of that type) on msg, so that session. This disables the actions of SoupSessionFeatures with the given feature_type (or a subclass of that type) on msg, so that session. Eg, passing SOUP_TYPE_PROXY_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. 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. Parameters: Number feature_type Required (not null) the GType of a SoupSessionFeature Returns: none	Soup.Message
	finished () : none Emits the finished signal, indicating that msg has been completely processed. Emits the finished signal, indicating that msg has been completely processed. Returns: none	Soup.Message
	get_address () : Soup.Address Gets 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. Returns: Soup.Address the address msg's URI points to	Soup.Message
	get_first_party () : Soup.URI Returns: Soup.URI the msg's first party SoupURI	Soup.Message
	get_flags () : Soup.MessageFlags Gets the flags on msg Gets the flags on msg Returns: Soup.MessageFlags the flags	Soup.Message
	get_http_version () : Soup.HTTPVersion Gets the HTTP version of msg. Gets the HTTP version of msg. This is the minimum of the version from the request and the version from the response. Returns: Soup.HTTPVersion the HTTP version	Soup.Message
	get_https_status (Object *out_values) : gboolean If msg* is using https, this retrieves the GTlsCertificate associated with its connection, and the GTlsCertificateFlags showing what problems, if any, have been found with that certificate. If msg is using https, this retrieves the GTlsCertificate associated with its connection, and the GTlsCertificateFlags showing what problems, if any, have been found with that certificate. Parameters: Object out_values Gio.TlsCertificate certificate Gio.TlsCertificateFlags errors Returns: gboolean TRUE if msg uses https, FALSE if not	Soup.Message
	get_uri () : Soup.URI Gets msg's URI Gets msg's URI Returns: Soup.URI the URI msg is targeted for.	Soup.Message
	got_body () : none Emits the got_body signal, indicating that the IO layer finished reading the body for msg. Emits the got_body signal, indicating that the IO layer finished reading the body for msg. Returns: none	Soup.Message
	got_chunk (Buffer *chunk) : none Emits the got_chunk* signal, indicating that the IO layer finished reading a chunk of msg's body. Emits the got_chunk signal, indicating that the IO layer finished reading a chunk of msg's body. Parameters: Soup.Buffer chunk Required (not null) the newly-read chunk Returns: none	Soup.Message
	got_headers () : none Emits the got_headers signal, indicating that the IO layer finished reading the (non-informational) headers for msg. Emits the got_headers signal, indicating that the IO layer finished reading the (non-informational) headers for msg. Returns: none	Soup.Message
	got_informational () : none Emits the got_informational signal, indicating that the IO layer read a complete informational (1xx) response for msg. Emits the got_informational signal, indicating that the IO layer read a complete informational (1xx) response for msg. Returns: none	Soup.Message
	is_keepalive () : gboolean 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. 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. Returns: gboolean TRUE or FALSE.	Soup.Message
	restarted () : none Emits the restarted signal, indicating that msg should be requeued. Emits the restarted signal, indicating that msg should be requeued. Returns: none	Soup.Message
	set_chunk_allocator (Function *allocator, void *user_data, Function destroy_notify) : none Sets an alternate chunk-allocation function to use when reading call allocator, which should return a SoupBuffer. Sets an alternate chunk-allocation function to use when reading call allocator, which should return a SoupBuffer. (See SoupChunkAllocator* 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. Generally, a custom chunk allocator would be used in conjunction with soup_message_body_set_accumulate() FALSE and SoupMessage::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 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 soup_buffer_new_with_owner() rather than doing the cleanup from the got_chunk handler. The other thing to remember when using non-accumulating message bodies is that the buffer passed to the 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 SoupBuffer (or its owner, in the soup_buffer_new_with_owner() case) to ensure that the data remains valid. Parameters: Function (Message *msg, guint32 max_len, void *user_data) : none Required (not null) the chunk allocator callback void user_data Required (not null) data to pass to allocator Function (void* *data) : none Required (not null) destroy notifier to free user_data* when msg is destroyed Returns: none	Soup.Message
	set_first_party (URI *first_party) : none Sets first_party* as the main document SoupURI for msg. Sets first_party as the main document SoupURI for msg. For details of when and how this is used refer to the documentation for SoupCookieJarAcceptPolicy. Parameters: Soup.URI first_party Required (not null) the SoupURI for the msg's first party Returns: none	Soup.Message
	set_flags (MessageFlags *flags) : none Sets the specified flags on msg. Sets the specified flags on msg. Parameters: Soup.MessageFlags flags* Required (not null) a set of SoupMessageFlags values Returns: none	Soup.Message
	set_http_version (HTTPVersion *version) : none Sets the HTTP version on msg. 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. Parameters: Soup.HTTPVersion version* Required (not null) the HTTP version Returns: none	Soup.Message
	set_request (String *content_type, MemoryUse req_use, String req_body, guint32 req_length) : none Convenience function to set the request body of a SoupMessage. Convenience function to set the request body of a SoupMessage. If Parameters: String content_type* Required (not null) MIME Content-Type of the body Soup.MemoryUse req_use Required (not null) a SoupMemoryUse describing how to handle req_body String req_body Required (not null) a data buffer containing the body of the message request. guint32 req_length Required (not null) the byte length of req_body. Returns: none	Soup.Message
	set_response (String *content_type, MemoryUse resp_use, String resp_body, guint32 resp_length) : none Convenience function to set the response body of a SoupMessage. Convenience function to set the response body of a SoupMessage. If Parameters: String content_type* MIME Content-Type of the body Soup.MemoryUse resp_use Required (not null) a SoupMemoryUse describing how to handle resp_body String resp_body Required (not null) a data buffer containing the body of the message response. guint32 resp_length Required (not null) the byte length of resp_body. Returns: none	Soup.Message
	set_status (guint32 *status_code) : none Sets msg's status code to 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. Parameters: guint32 status_code Required (not null) an HTTP status code Returns: none	Soup.Message
	set_status_full (guint32 *status_code, String reason_phrase) : none Sets msg's status code and reason phrase. Sets msg's status code and reason phrase. Parameters: guint32 status_code* Required (not null) an HTTP status code String reason_phrase Required (not null) a description of the status Returns: none	Soup.Message
	set_uri (URI *uri) : none Sets msg's URI to 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(). Parameters: Soup.URI uri Required (not null) the new SoupURI Returns: none	Soup.Message
	wrote_body () : none Emits the wrote_body signal, indicating that the IO layer finished writing the body for msg. Emits the wrote_body signal, indicating that the IO layer finished writing the body for msg. Returns: none	Soup.Message
	wrote_body_data (Buffer *chunk) : none Emits the wrote_body_data* signal, indicating that the IO layer finished writing a portion of msg's body. Emits the wrote_body_data signal, indicating that the IO layer finished writing a portion of msg's body. Parameters: Soup.Buffer chunk Required (not null) the data written Returns: none	Soup.Message
	wrote_chunk () : none Emits the wrote_chunk signal, indicating that the IO layer finished writing a chunk of msg's body. Emits the wrote_chunk signal, indicating that the IO layer finished writing a chunk of msg's body. Returns: none	Soup.Message
	wrote_headers () : none Emits the wrote_headers signal, indicating that the IO layer finished writing the (non-informational) headers for msg. Emits the wrote_headers signal, indicating that the IO layer finished writing the (non-informational) headers for msg. Returns: none	Soup.Message
	wrote_informational () : none Emits the wrote_informational signal, indicating that the IO layer finished writing an informational (1xx) response for msg. Emits the wrote_informational signal, indicating that the IO layer finished writing an informational (1xx) response for msg. Returns: none	Soup.Message

Events - usage syntax: this.signals.EVENTNAME.connect( Function )
Event		Defined By
	content_sniffed (Message *self, String object, Object p0) : none Parameters: Soup.Message self* String object Object p0 Returns: {none}	Soup.Message
	finished (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message
	got_body (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message
	got_chunk (Message *self, Buffer object) : none Parameters: Soup.Message self* Soup.Buffer object Returns: {none}	Soup.Message
	got_headers (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message
	got_informational (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message
	restarted (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message
	wrote_body (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message
	wrote_body_data (Message *self, Buffer object) : none Parameters: Soup.Message self* Soup.Buffer object Returns: {none}	Soup.Message
	wrote_chunk (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message
	wrote_headers (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message
	wrote_informational (Message *self) : none Parameters: Soup.Message self* Returns: {none}	Soup.Message

Used by These Methods / Signals / Properties
Class / Namespace	Method / Signal / Properties
Soup Method	Soup.cookies_from_request (Message *msg) : Array Parses msg's Cookie request header and returns a GSList* of SoupCookies.
Soup Method	Soup.cookies_from_response (Message *msg) : Array Parses msg's Set-Cookie response headers and returns a GSList* of SoupCookies.
Soup Method	Soup.cookies_to_request (Array *cookies, Message msg) : none Adds the name and value of each cookie in cookies* to msg's "Cookie" request.
Soup Method	Soup.cookies_to_response (Array *cookies, Message msg) : none Appends a "Set-Cookie" response header to msg* for each cookie in
Soup Method	Soup.form_decode_multipart (Message *msg, String file_control_name, Object out_values) : Object Decodes the "multipart/form-data" request in msg*; this is a convenience method for the case when you have a single file upload control in a form.
Soup Method	Soup.form_request_new_from_datalist (String *method, String uri, Data form_data_set) : Soup.Message Creates a new SoupMessage* and sets it up to send form_data_set to
Soup Method	Soup.form_request_new_from_hash (String *method, String uri, Object form_data_set) : Soup.Message Creates a new SoupMessage* and sets it up to send form_data_set to
Soup Method	Soup.form_request_new_from_multipart (String *uri, Multipart multipart) : Soup.Message Creates a new SoupMessage* and sets it up to send multipart to To send a "multipart/form-data" POST, first create a SoupMultipart, using SOUP_FORM_MIME_TYPE_MULTIPART as the MIME type.
Soup.Auth Method	new Soup.Auth.c_new (Number *type, Message msg, String auth_header*) : Soup.Auth Create a new Soup.Auth
Soup.Auth Method	get_authorization (Message *msg) : String Generates an appropriate "Authorization" header for msg*.
Soup.Auth Method	update (Message *msg, String auth_header) : gboolean Updates auth* with the information from msg and auth_header, possibly un-authenticating it.
Soup.AuthDomain Method	accepts (Message *msg) : String Checks if msg* contains appropriate authorization for domain to accept it.
Soup.AuthDomain Method	challenge (Message *msg) : none Adds a "WWW-Authenticate" or "Proxy-Authenticate" header to msg, requesting that the client authenticate, and sets msg*'s status accordingly.
Soup.AuthDomain Method	check_password (Message *msg, String username, String password) : gboolean Checks if msg* authenticates to domain via username and SoupAuthDomainGenericAuthCallback.
Soup.AuthDomain Method	covers (Message *msg) : gboolean Checks if domain* requires msg to be authenticated (according to its paths and filter function).
Soup.AuthDomain Method	try_generic_auth_callback (Message *msg, String username*) : gboolean
Soup.ContentSniffer Method	sniff (Message *msg, Buffer buffer, Object params*) : String
Soup.ProxyResolver Method	get_proxy_sync (Message *msg, Cancellable cancellable, Address addr*) : guint32
Soup.Server Signal	request_aborted (Server *self, Message object*, ClientContext p0) : none
Soup.Server Signal	request_finished (Server *self, Message object*, ClientContext p0) : none
Soup.Server Signal	request_read (Server *self, Message object*, ClientContext p0) : none
Soup.Server Signal	request_started (Server *self, Message object*, ClientContext p0) : none
Soup.Server Method	pause_message (Message *msg) : none Pauses I/O on msg*.
Soup.Server Method	unpause_message (Message *msg) : none Resumes I/O on msg*.
Soup.Session Signal	authenticate (Session *self, Message object*, Auth p0, gboolean p1) : none
Soup.Session Signal	request_queued (Session *self, Message object*) : none
Soup.Session Signal	request_started (Session *self, Message object*, Socket p0) : none
Soup.Session Signal	request_unqueued (Session *self, Message object*) : none
Soup.Session Method	cancel_message (Message *msg, guint32 status_code) : none Causes session* to immediately finish processing msg (regardless of its current state) with a final status_code of status_code.
Soup.Session Method	get_feature_for_message (Number *feature_type, Message msg) : Soup.SessionFeature Gets the first feature in session* of type feature_type, provided that it is not disabled for msg.
Soup.Session Method	pause_message (Message *msg) : none Pauses HTTP I/O on msg*.
Soup.Session Method	queue_message (Message *msg, Function callback, void *user_data) : none Queues the message msg* for sending.
Soup.Session Method	requeue_message (Message *msg) : none This causes msg* to be placed back on the queue to be attempted again.
Soup.Session Method	send_message (Message *msg) : guint32 Synchronously send msg*.
Soup.Session Method	unpause_message (Message *msg) : none Resumes HTTP I/O on msg*.
WebKit.NetworkRequest Property	message : Soup.Message The SoupMessage that backs the request.
WebKit.NetworkRequest Method	get_message () : Soup.Message Obtains the SoupMessage held and used by the given request.
WebKit.NetworkResponse Property	message : Soup.Message The SoupMessage that backs the response.
WebKit.NetworkResponse Method	get_message () : Soup.Message Obtains the SoupMessage that represents the given response.
WebKit.SoupAuthDialog Signal	current_toplevel (SoupAuthDialog *self, Message message) : Gtk.Widget This signal is emitted by the authDialog* when it needs to know the current toplevel widget in order to correctly set the transiency for the authentication dialog.