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
	Show / Hide Inherited methods, properties and signals

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 : Boolean	Soup.Message
	status_code : Number	Soup.Message
	status_code : Number read only	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) String uri_string Required (not null) Returns: Soup.Message
	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) Soup.URI uri Required (not null) Returns: Soup.Message
	add_header_handler (String *signal, String header, Function callback, void *user_data) : Number Adds a signal handler to msg* for signal, as with 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. Adds a signal handler to msg for signal, as with 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. If signal is one of the "got" signals (eg, "got_headers"), or "finished" or "restarted", then header is matched against the incoming message headers (that is, the request_headers for a client SoupMessage, or the response_headers for a server SoupMessage). If signal is one of the "wrote" signals, then Parameters: String signal Required (not null) String header Required (not null) Function () : Number Required (not null) void* user_data Required (not null) Returns: Number	Soup.Message
	add_status_code_handler (String *signal, Number status_code, Function callback, void *user_data) : Number Adds a signal handler to msg* for signal, as with 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. Adds a signal handler to msg for signal, as with 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. is set. For a client SoupMessage, this means it can't be a "wrote" signal. For a server SoupMessage, this means it can't be a "got" signal. Parameters: String signal Required (not null) Number status_code Required (not null) Function () : Number Required (not null) void* user_data Required (not null) Returns: Number	Soup.Message
	cleanup_response () : none Cleans up all response data on req, so that the request can be sent again and receive a new response. Cleans up all response data on req, so that the request can be sent again and receive a new response. (Eg, as a result of a redirect or authorization request.) Returns: none	Soup.Message
	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) 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) Returns: none	Soup.Message
	disables_feature (void* *feature) : Boolean Parameters: void feature Required (not null) Returns: Boolean	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	Soup.Message
	get_auth () : Soup.Auth Gets the SoupAuth used by msg for authentication. Gets the SoupAuth used by msg for authentication. NULL if msg is unauthenticated. Returns: Soup.Auth	Soup.Message
	get_first_party () : Soup.URI Returns: Soup.URI	Soup.Message
	get_flags () : Soup.MessageFlags Gets the flags on msg Gets the flags on msg Returns: Soup.MessageFlags	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	Soup.Message
	get_io_status () : Soup.MessageIOStatus Returns: Soup.MessageIOStatus	Soup.Message
	get_proxy_auth () : Soup.Auth Gets the SoupAuth used by msg for authentication to its proxy. Gets the SoupAuth used by msg for authentication to its proxy.. proxy, or NULL if msg isn't authenticated to its proxy. Returns: Soup.Auth	Soup.Message
	get_uri () : Soup.URI Gets msg's URI Gets msg's URI Returns: Soup.URI	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) 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
	io_cleanup () : none Returns: none	Soup.Message
	io_client (Socket *sock, Connection conn, Function get_headers_cb, Function parse_headers_cb, void *user_data) : none Parameters: Soup.Socket sock* Required (not null) Soup.Connection conn Required (not null) Function (Message *msg, String headers, Encoding encoding, void *user_data) : none Required (not null) Function (Message msg, String headers, Number header_len, Encoding encoding, void *user_data) : none Required (not null) void user_data Required (not null) Returns: none	Soup.Message
	io_in_progress () : Boolean Tests whether or not I/O is currently in progress on msg. Tests whether or not I/O is currently in progress on msg. Returns: Boolean	Soup.Message
	io_pause () : none Returns: none	Soup.Message
	io_server (Socket *sock, Function get_headers_cb, Function parse_headers_cb, void *user_data) : none Parameters: Soup.Socket sock* Required (not null) Function (Message *msg, String headers, Encoding encoding, void *user_data) : none Required (not null) Function (Message msg, String headers, Number header_len, Encoding encoding, void *user_data) : none Required (not null) void user_data Required (not null) Returns: none	Soup.Message
	io_stop () : none Immediately stops I/O on msg; if the connection would be left in an inconsistent state, it will be closed. Immediately stops I/O on msg; if the connection would be left in an inconsistent state, it will be closed. to be emitted on msg; it is up to the caller to make sure that Returns: none	Soup.Message
	io_unpause () : none Returns: none	Soup.Message
	is_keepalive () : Boolean 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: Boolean	Soup.Message
	read_request (Socket *sock) : none Parameters: Soup.Socket sock* Required (not null) Returns: none	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
	send_request (Socket *sock, Connection conn, Boolean via_proxy) : none Parameters: Soup.Socket sock* Required (not null) Soup.Connection conn Required (not null) Boolean via_proxy Required (not null) Returns: none	Soup.Message
	set_auth (Auth *auth) : none Sets msg* to authenticate to its destination using auth, which must have already been fully authenticated. Sets msg to authenticate to its destination using auth, which must have already been fully authenticated. If auth is NULL, msg will not authenticate to its destination. Parameters: Soup.Auth auth Required (not null) Returns: none	Soup.Message
	set_chunk_allocator (Function *allocator, void *user_data, Function destroy_notify) : none destroyed Sets an alternate chunk-allocation function to use when reading call allocator, which should return a SoupBuffer. destroyed 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, Number max_len, void *user_data) : none Required (not null) void user_data Required (not null) Function (void* *data*) : none Required (not null) 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) 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) 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) Returns: none	Soup.Message
	set_io_status (MessageIOStatus *status) : none Parameters: Soup.MessageIOStatus status* Required (not null) Returns: none	Soup.Message
	set_proxy_auth (Auth *auth) : none Sets msg* to authenticate to its proxy using auth, which must have already been fully authenticated. Sets msg to authenticate to its proxy using auth, which must have already been fully authenticated. If auth is NULL, msg will not authenticate to its proxy. Parameters: Soup.Auth auth Required (not null) Returns: none	Soup.Message
	set_request (String *content_type, MemoryUse req_use, String req_body, Number 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) Soup.MemoryUse req_use Required (not null) String req_body Required (not null) Number req_length Required (not null) Returns: none	Soup.Message
	set_response (String *content_type, MemoryUse resp_use, String resp_body, Number resp_length) : none containing the body of the message response. containing the body of the message response. 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) String resp_body Required (not null) a data buffer Number resp_length Required (not null) Returns: none	Soup.Message
	set_status (Number *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: Number status_code Required (not null) Returns: none	Soup.Message
	set_status_full (Number *status_code, String reason_phrase) : none Sets msg's status code and reason phrase. Sets msg's status code and reason phrase. Parameters: Number status_code* Required (not null) String reason_phrase Required (not null) 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) 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) 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, Array filename, Array content_type, Buffer file) : 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	update (Message *msg, String auth_header) : Boolean Updates auth* with the information from msg and auth_header, possibly un-authenticating it.
Soup.Auth Method	get_authorization (Message *msg) : String Generates an appropriate "Authorization" header for msg*.
Soup.AuthDomain Method	check_password (Message *msg, String username, String password) : Boolean Checks if msg* authenticates to domain via username and SoupAuthDomainGenericAuthCallback.
Soup.AuthDomain Method	covers (Message *msg) : Boolean Checks if domain* requires msg to be authenticated (according to its paths and filter function).
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	try_generic_auth_callback (Message *msg, String username*) : Boolean
Soup.AuthManager Signal	authenticate (AuthManager *self, Message object*, Auth p0, Boolean p1) : none
Soup.AuthManager Method	emit_authenticate (Message *msg, Auth auth, Boolean retrying*) : none
Soup.Connection Property	message : Soup.Message read only
Soup.Connection Method	send_request (Message *req) : none Sends req* on conn.
Soup.ContentSniffer Method	sniff (Message *msg, Buffer buffer, Object params*) : String
Soup.MessageQueue Method	append (Message *msg, Function callback, void *user_data) : Soup.MessageQueueItem Creates a new SoupMessageQueueItem* and appends it to queue.
Soup.MessageQueue Method	lookup (Message *msg) : Soup.MessageQueueItem Finds the SoupMessageQueueItem* for msg in queue.
Soup.ProxyResolver Method	get_proxy_async (Message *msg, MainContext async_context, Cancellable cancellable, Function callback, void *user_data*) : none
Soup.ProxyResolver Method	get_proxy_sync (Message *msg, Cancellable cancellable, Address addr*) : Number
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, Boolean 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	queue_message (Message *msg, Function callback, void *user_data*) : none be called after the message completes or when an unrecoverable error occurs.
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) : Number Synchronously send msg*.
Soup.Session Method	pause_message (Message *msg) : none Pauses HTTP I/O on msg*.
Soup.Session Method	unpause_message (Message *msg) : none Resumes HTTP I/O on msg*.
Soup.Session Method	cancel_message (Message *msg, Number status_code) : none SOUP_STATUS_CANCELLED) 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.
WebKit.NetworkRequest Property	message : Soup.Message
WebKit.NetworkRequest Method	get_message () : Soup.Message
WebKit.NetworkResponse Property	message : Soup.Message
WebKit.NetworkResponse Method	get_message () : Soup.Message
WebKit.SoupAuthDialog Signal	current_toplevel (SoupAuthDialog *self, Message object*) : Gtk.Widget