This can be passed to any #SoupAddress method that expects a port, to indicate that you don't care what port is used. Alias for the #SoupAddress:family property. (The #SoupAddressFamily for this address.) Alias for the #SoupAddress:name property. (The hostname for this address.) An alias for the #SoupAddress:physical property. (The stringified IP address for this address.) An alias for the #SoupAddress:port property. (The port for this address.) Alias for the #SoupAddress:protocol property. (The URI scheme used with this address.) An alias for the #SoupAddress:sockaddr property. (A pointer to the struct sockaddr for this address.) Alias for the #SoupAuthDomain:add-path property. (Shortcut for calling soup_auth_domain_add_path().) Alias for the #SoupAuthDomainBasic:auth-callback property. (The #SoupAuthDomainBasicAuthCallback.) Alias for the #SoupAuthDomainBasic:auth-data property. (The data to pass to the #SoupAuthDomainBasicAuthCallback.) Alias for the #SoupAuthDomainDigest:auth-callback property. (The #SoupAuthDomainDigestAuthCallback.) Alias for the #SoupAuthDomainDigest:auth-callback property. (The #SoupAuthDomainDigestAuthCallback.) Alias for the #SoupAuthDomain:filter property. (The #SoupAuthDomainFilter for the domain.) Alias for the #SoupAuthDomain:filter-data property. (Data to pass to the #SoupAuthDomainFilter.) Alias for the #SoupAuthDomain:generic-auth-callback property. (The #SoupAuthDomainGenericAuthCallback.) Alias for the #SoupAuthDomain:generic-auth-data property. (The data to pass to the #SoupAuthDomainGenericAuthCallback.) Alias for the #SoupAuthDomain:proxy property. (Whether or not this is a proxy auth domain.) Alias for the #SoupAuthDomain:realm property. (The realm of this auth domain.) Alias for the #SoupAuthDomain:remove-path property. (Shortcut for calling soup_auth_domain_remove_path().) An alias for the #SoupAuth:host property. (The host being authenticated to.) An alias for the #SoupAuth:is-authenticated property. (Whether or not the auth has been authenticated.) An alias for the #SoupAuth:is-for-proxy property. (Whether or not the auth is for a proxy server.) An alias for the #SoupAuth:realm property. (The authentication realm.) An alias for the #SoupAuth:scheme-name property. (The authentication scheme name.) Creates a #SoupAddress from @name and @port. The #SoupAddress's IP address may not be available right away; the caller can call soup_address_resolve_async() or soup_address_resolve_sync() to force a DNS resolution. a #SoupAddress a hostname or physical address a port number Returns a #SoupAddress corresponding to the "any" address for @family (or %NULL if @family isn't supported), suitable for using as a listening #SoupSocket. the new #SoupAddress the address family the port number (usually %SOUP_ADDRESS_ANY_PORT) Returns a #SoupAddress equivalent to @sa (or %NULL if @sa's address family isn't supported) the new #SoupAddress a pointer to a sockaddr size of @sa Tests if @addr1 and @addr2 have the same IP address. This method can be used with soup_address_hash_by_ip() to create a #GHashTable that hashes on IP address. This would be used to distinguish hosts in situations where different virtual hosts on the same IP address should be considered the same. Eg, if "www.example.com" and "www.example.net" have the same IP address, then a single connection can be used to talk to either of them. See also soup_address_equal_by_name(), which compares by name rather than by IP address. whether or not @addr1 and @addr2 have the same IP address. a #SoupAddress with a resolved IP address another #SoupAddress with a resolved IP address Tests if @addr1 and @addr2 have the same "name". This method can be used with soup_address_hash_by_name() to create a #GHashTable that hashes on address "names". Comparing by name normally means comparing the addresses by their hostnames. But if the address was originally created using an IP address literal, then it will be compared by that instead. In particular, if "www.example.com" has the IP address 10.0.0.1, and @addr1 was created with the name "www.example.com" and @addr2 was created with the name "10.0.0.1", then they will compare as unequal for purposes of soup_address_equal_by_name(). This would be used to distinguish hosts in situations where different virtual hosts on the same IP address should be considered different. Eg, for purposes of HTTP authentication or cookies, two hosts with the same IP address but different names are considered to be different hosts. See also soup_address_equal_by_ip(), which compares by IP address rather than by name. whether or not @addr1 and @addr2 have the same name a #SoupAddress with a resolved name another #SoupAddress with a resolved name Creates a new #GSocketAddress corresponding to @addr (which is assumed to only have one socket address associated with it). a new #GSocketAddress a #SoupAddress Returns the hostname associated with @addr. This method is not thread-safe; if you call it while @addr is being resolved in another thread, it may return garbage. You can use soup_address_is_resolved() to safely test whether or not an address is resolved before fetching its name or address. the hostname, or %NULL if it is not known. a #SoupAddress Returns the physical address associated with @addr as a string. (Eg, "127.0.0.1"). If the address is not yet known, returns %NULL. This method is not thread-safe; if you call it while @addr is being resolved in another thread, it may return garbage. You can use soup_address_is_resolved() to safely test whether or not an address is resolved before fetching its name or address. the physical address, or %NULL a #SoupAddress Returns the port associated with @addr. the port a #SoupAddress Returns the sockaddr associated with @addr, with its length in *@len. If the sockaddr is not yet known, returns %NULL. This method is not thread-safe; if you call it while @addr is being resolved in another thread, it may return garbage. You can use soup_address_is_resolved() to safely test whether or not an address is resolved before fetching its name or address. the sockaddr, or %NULL a #SoupAddress return location for sockaddr length A hash function (for #GHashTable) that corresponds to soup_address_equal_by_ip(), qv the IP-based hash value for @addr. a #SoupAddress A hash function (for #GHashTable) that corresponds to soup_address_equal_by_name(), qv the named-based hash value for @addr. a #SoupAddress Tests if @addr has already been resolved. Unlike the other #SoupAddress "get" methods, this is safe to call when @addr might be being resolved in another thread. %TRUE if @addr has been resolved. a #SoupAddress Asynchronously resolves the missing half of @addr (its IP address if it was created with soup_address_new(), or its hostname if it was created with soup_address_new_from_sockaddr() or soup_address_new_any().) If @cancellable is non-%NULL, it can be used to cancel the resolution. @callback will still be invoked in this case, with a status of %SOUP_STATUS_CANCELLED. It is safe to call this more than once on a given address, from the same thread, with the same @async_context (and doing so will not result in redundant DNS queries being made). But it is not safe to call from multiple threads, or with different @async_contexts, or mixed with calls to soup_address_resolve_sync(). a #SoupAddress the #GMainContext to call @callback from a #GCancellable object, or %NULL callback to call with the result data for @callback Synchronously resolves the missing half of @addr, as with soup_address_resolve_async(). If @cancellable is non-%NULL, it can be used to cancel the resolution. soup_address_resolve_sync() will then return a status of %SOUP_STATUS_CANCELLED. It is safe to call this more than once, even from different threads, but it is not safe to mix calls to soup_address_resolve_sync() with calls to soup_address_resolve_async() on the same address. %SOUP_STATUS_OK, %SOUP_STATUS_CANT_RESOLVE, or %SOUP_STATUS_CANCELLED. a #SoupAddress a #GCancellable object, or %NULL The callback function passed to soup_address_resolve_async(). the #SoupAddress that was resolved %SOUP_STATUS_OK, %SOUP_STATUS_CANT_RESOLVE, or %SOUP_STATUS_CANCELLED the user data that was passed to soup_address_resolve_async() The supported address families. an invalid %SoupAddress an IPv4 address an IPv6 address The abstract base class for handling authentication. Specific HTTP Authentication mechanisms are implemented by its subclasses, but applications never need to be aware of the specific subclasses being used. Creates a new #SoupAuth of type @type with the information from @msg and @auth_header. This is called by #SoupSession; you will normally not create auths yourself. the new #SoupAuth, or %NULL if it could not be created the type of auth to create (a subtype of #SoupAuth) the #SoupMessage the auth is being created for the WWW-Authenticate/Proxy-Authenticate header Call this on an auth to authenticate it; normally this will cause the auth's message to be requeued with the new authentication info. a #SoupAuth the username provided by the user or client the password provided by the user or client Tests if @auth is able to authenticate by providing credentials to the soup_auth_authenticate(). %TRUE if @auth is able to accept credentials. a #SoupAuth Generates an appropriate "Authorization" header for @msg. (The session will only call this if soup_auth_is_authenticated() returned %TRUE.) the "Authorization" header, which must be freed. a #SoupAuth the #SoupMessage to be authorized Returns a list of paths on the server which @auth extends over. (All subdirectories of these paths are also assumed to be part of @auth's protection space, unless otherwise discovered not to be.) the list of paths, which can be freed with soup_auth_free_protection_space(). a #SoupAuth the URI of the request that @auth was generated in response to. Tests if @auth has been given a username and password %TRUE if @auth has been given a username and password a #SoupAuth Tests if @auth is ready to make a request for @msg with. For most auths, this is equivalent to soup_auth_is_authenticated(), but for some auth types (eg, NTLM), the auth may be sendable (eg, as an authentication request) even before it is authenticated. %TRUE if @auth is ready to make a request with. a #SoupAuth a #SoupMessage Updates @auth with the information from @msg and @auth_header, possibly un-authenticating it. As with soup_auth_new(), this is normally only used by #SoupSession. %TRUE if @auth is still a valid (but potentially unauthenticated) #SoupAuth. %FALSE if something about @auth_params could not be parsed or incorporated into @auth at all. a #SoupAuth the #SoupMessage @auth is being updated for the WWW-Authenticate/Proxy-Authenticate header Call this on an auth to authenticate it; normally this will cause the auth's message to be requeued with the new authentication info. a #SoupAuth the username provided by the user or client the password provided by the user or client Tests if @auth is able to authenticate by providing credentials to the soup_auth_authenticate(). %TRUE if @auth is able to accept credentials. a #SoupAuth Frees @space. a #SoupAuth the return value from soup_auth_get_protection_space() Generates an appropriate "Authorization" header for @msg. (The session will only call this if soup_auth_is_authenticated() returned %TRUE.) the "Authorization" header, which must be freed. a #SoupAuth the #SoupMessage to be authorized Returns the host that @auth is associated with. the hostname a #SoupAuth Gets an opaque identifier for @auth, for use as a hash key or the like. #SoupAuth objects from the same server with the same identifier refer to the same authentication domain (eg, the URLs associated with them take the same usernames and passwords). the identifier a #SoupAuth Returns a list of paths on the server which @auth extends over. (All subdirectories of these paths are also assumed to be part of @auth's protection space, unless otherwise discovered not to be.) the list of paths, which can be freed with soup_auth_free_protection_space(). a #SoupAuth the URI of the request that @auth was generated in response to. Returns @auth's realm. This is an identifier that distinguishes separate authentication spaces on a given server, and may be some string that is meaningful to the user. (Although it is probably not localized.) the realm name a #SoupAuth Returns @auth's scheme name. (Eg, "Basic", "Digest", or "NTLM") the scheme name a #SoupAuth Tests if @auth has been given a username and password %TRUE if @auth has been given a username and password a #SoupAuth Tests whether or not @auth is associated with a proxy server rather than an "origin" server. %TRUE or %FALSE a #SoupAuth Tests if @auth is ready to make a request for @msg with. For most auths, this is equivalent to soup_auth_is_authenticated(), but for some auth types (eg, NTLM), the auth may be sendable (eg, as an authentication request) even before it is authenticated. %TRUE if @auth is ready to make a request with. a #SoupAuth a #SoupMessage Updates @auth with the information from @msg and @auth_header, possibly un-authenticating it. As with soup_auth_new(), this is normally only used by #SoupSession. %TRUE if @auth is still a valid (but potentially unauthenticated) #SoupAuth. %FALSE if something about @auth_params could not be parsed or incorporated into @auth at all. a #SoupAuth the #SoupMessage @auth is being updated for the WWW-Authenticate/Proxy-Authenticate header %TRUE if @auth is still a valid (but potentially unauthenticated) #SoupAuth. %FALSE if something about @auth_params could not be parsed or incorporated into @auth at all. a #SoupAuth the #SoupMessage @auth is being updated for the WWW-Authenticate/Proxy-Authenticate header the list of paths, which can be freed with soup_auth_free_protection_space(). a #SoupAuth the URI of the request that @auth was generated in response to. a #SoupAuth the username provided by the user or client the password provided by the user or client %TRUE if @auth has been given a username and password a #SoupAuth the "Authorization" header, which must be freed. a #SoupAuth the #SoupMessage to be authorized %TRUE if @auth is ready to make a request with. a #SoupAuth a #SoupMessage %TRUE if @auth is able to accept credentials. a #SoupAuth Adds a "WWW-Authenticate" or "Proxy-Authenticate" header to @msg, requesting that the client authenticate, and sets @msg's status accordingly. This is used by #SoupServer internally and is probably of no use to anyone else. a #SoupAuthDomain a #SoupMessage Checks if @msg authenticates to @domain via @username and @password. This would normally be called from a #SoupAuthDomainGenericAuthCallback. whether or not the message is authenticated a #SoupAuthDomain a #SoupMessage a username a password Checks if @msg contains appropriate authorization for @domain to accept it. Mirroring soup_auth_domain_covers(), this does not check whether or not @domain <emphasis>cares</emphasis> if @msg is authorized. This is used by #SoupServer internally and is probably of no use to anyone else. the username that @msg has authenticated as, if in fact it has authenticated. %NULL otherwise. a #SoupAuthDomain a #SoupMessage Adds @path to @domain, such that requests under @path on @domain's server will require authentication (unless overridden by soup_auth_domain_remove_path() or soup_auth_domain_set_filter()). You can also add paths by setting the %SOUP_AUTH_DOMAIN_ADD_PATH property, which can also be used to add one or more paths at construct time. a #SoupAuthDomain the path to add to @domain Adds a "WWW-Authenticate" or "Proxy-Authenticate" header to @msg, requesting that the client authenticate, and sets @msg's status accordingly. This is used by #SoupServer internally and is probably of no use to anyone else. a #SoupAuthDomain a #SoupMessage Checks if @msg authenticates to @domain via @username and @password. This would normally be called from a #SoupAuthDomainGenericAuthCallback. whether or not the message is authenticated a #SoupAuthDomain a #SoupMessage a username a password Checks if @domain requires @msg to be authenticated (according to its paths and filter function). This does not actually look at whether @msg <emphasis>is</emphasis> authenticated, merely whether or not it needs to be. This is used by #SoupServer internally and is probably of no use to anyone else. %TRUE if @domain requires @msg to be authenticated a #SoupAuthDomain a #SoupMessage Gets the realm name associated with @domain @domain's realm a #SoupAuthDomain Removes @path from @domain, such that requests under @path on @domain's server will NOT require authentication. This is not simply an undo-er for soup_auth_domain_add_path(); it can be used to "carve out" a subtree that does not require authentication inside a hierarchy that does. Note also that unlike with soup_auth_domain_add_path(), this cannot be overridden by adding a filter, as filters can only bypass authentication that would otherwise be required, not require it where it would otherwise be unnecessary. You can also remove paths by setting the %SOUP_AUTH_DOMAIN_REMOVE_PATH property, which can also be used to remove one or more paths at construct time. a #SoupAuthDomain the path to remove from @domain Adds @filter as an authentication filter to @domain. The filter gets a chance to bypass authentication for certain requests that would otherwise require it. Eg, it might check the message's path in some way that is too complicated to do via the other methods, or it might check the message's method, and allow GETs but not PUTs. The filter function returns %TRUE if the request should still require authentication, or %FALSE if authentication is unnecessary for this request. To help prevent security holes, your filter should return %TRUE by default, and only return %FALSE under specifically-tested circumstances, rather than the other way around. Eg, in the example above, where you want to authenticate PUTs but not GETs, you should check if the method is GET and return %FALSE in that case, and then return %TRUE for all other methods (rather than returning %TRUE for PUT and %FALSE for all other methods). This way if it turned out (now or later) that some paths supported additional methods besides GET and PUT, those methods would default to being NOT allowed for unauthenticated users. You can also set the filter by setting the %SOUP_AUTH_DOMAIN_FILTER and %SOUP_AUTH_DOMAIN_FILTER_DATA properties, which can also be used to set the filter at construct time. a #SoupAuthDomain the auth filter for @domain data to pass to @filter destroy notifier to free @filter_data when @domain is destroyed Sets @auth_callback as an authentication-handling callback for @domain. Whenever a request comes in to @domain which cannot be authenticated via a domain-specific auth callback (eg, #SoupAuthDomainDigestAuthCallback), the generic auth callback will be invoked. See #SoupAuthDomainGenericAuthCallback for information on what the callback should do. a #SoupAuthDomain the auth callback data to pass to @auth_callback destroy notifier to free @auth_data when @domain is destroyed The #SoupAuthDomainFilter for the domain The #SoupAuthDomainGenericAuthCallback for the domain Creates a #SoupAuthDomainBasic. You must set the %SOUP_AUTH_DOMAIN_REALM parameter, to indicate the realm name to be returned with the authentication challenge to the client. Other parameters are optional. the new #SoupAuthDomain name of first option, or %NULL option name/value pairs Sets the callback that @domain will use to authenticate incoming requests. For each request containing authorization, @domain will invoke the callback, and then either accept or reject the request based on @callback's return value. You can also set the auth callback by setting the %SOUP_AUTH_DOMAIN_BASIC_AUTH_CALLBACK and %SOUP_AUTH_DOMAIN_BASIC_AUTH_DATA properties, which can also be used to set the callback at construct time. the domain the callback data to pass to @auth_callback destroy notifier to free @user_data when @domain is destroyed The #SoupAuthDomainBasicAuthCallback The data to pass to the #SoupAuthDomainBasicAuthCallback Callback used by #SoupAuthDomainBasic for authentication purposes. The application should verify that @username and @password and valid and return %TRUE or %FALSE. If you are maintaining your own password database (rather than using the password to authenticate against some other system like PAM or a remote server), you should make sure you know what you are doing. In particular, don't store cleartext passwords, or easily-computed hashes of cleartext passwords, even if you don't care that much about the security of your server, because users will frequently use the same password for multiple sites, and so compromising any site with a cleartext (or easily-cracked) password database may give attackers access to other more-interesting sites as well. %TRUE if @username and @password are valid the domain the message being authenticated the username provided by the client the password provided by the client the data passed to soup_auth_domain_basic_set_auth_callback() a #SoupAuthDomain a #SoupMessage whether or not the message is authenticated a #SoupAuthDomain a #SoupMessage a username a password Creates a #SoupAuthDomainDigest. You must set the %SOUP_AUTH_DOMAIN_REALM parameter, to indicate the realm name to be returned with the authentication challenge to the client. Other parameters are optional. the new #SoupAuthDomain name of first option, or %NULL option name/value pairs Encodes the username/realm/password triplet for Digest authentication. (That is, it returns a stringified MD5 hash of @username, @realm, and @password concatenated together). This is the form that is needed as the return value of #SoupAuthDomainDigest's auth handler. For security reasons, you should store the encoded hash, rather than storing the cleartext password itself and calling this method only when you need to verify it. This way, if your server is compromised, the attackers will not gain access to cleartext passwords which might also be usable at other sites. (Note also that the encoded password returned by this method is identical to the encoded password stored in an Apache .htdigest file.) the encoded password a username an auth realm name the password for @username in @realm Sets the callback that @domain will use to authenticate incoming requests. For each request containing authorization, @domain will invoke the callback, and then either accept or reject the request based on @callback's return value. You can also set the auth callback by setting the %SOUP_AUTH_DOMAIN_DIGEST_AUTH_CALLBACK and %SOUP_AUTH_DOMAIN_DIGEST_AUTH_DATA properties, which can also be used to set the callback at construct time. the domain the callback data to pass to @auth_callback destroy notifier to free @user_data when @domain is destroyed The #SoupAuthDomainDigestAuthCallback The data to pass to the #SoupAuthDomainDigestAuthCallback Callback used by #SoupAuthDomainDigest for authentication purposes. The application should look up @username in its password database, and return the corresponding encoded password (see soup_auth_domain_digest_encode_password()). the encoded password, or %NULL if @username is not a valid user. @domain will free the password when it is done with it. the domain the message being authenticated the username provided by the client the data passed to soup_auth_domain_digest_set_auth_callback() The prototype for a #SoupAuthDomain filter; see soup_auth_domain_set_filter() for details. %TRUE if @msg requires authentication, %FALSE if not. a #SoupAuthDomain a #SoupMessage the data passed to soup_auth_domain_set_filter() The prototype for a #SoupAuthDomain generic authentication callback. The callback should look up the user's password, call soup_auth_domain_check_password(), and use the return value from that method as its own return value. In general, for security reasons, it is preferable to use the auth-domain-specific auth callbacks (eg, #SoupAuthDomainBasicAuthCallback and #SoupAuthDomainDigestAuthCallback), because they don't require keeping a cleartext password database. Most users will use the same password for many different sites, meaning if any site with a cleartext password database is compromised, accounts on other servers might be compromised as well. For many of the cases where #SoupServer is used, this is not really relevant, but it may still be worth considering. %TRUE if @msg is authenticated, %FALSE if not. a #SoupAuthDomain the #SoupMessage being authenticated the username from @msg the data passed to soup_auth_domain_set_generic_auth_callback() Clear all credentials cached by @manager a #SoupAuthManager Records that @auth is to be used under @uri, as though a WWW-Authenticate header had been received at that URI. This can be used to "preload" @manager's auth cache, to avoid an extra HTTP round trip in the case where you know ahead of time that a 401 response will be returned. This is only useful for authentication types where the initial Authorization header does not depend on any additional information from the server. (Eg, Basic or NTLM, but not Digest.) a #SoupAuthManager the #SoupURI under which @auth is to be used the #SoupAuth to use Emitted when the manager requires the application to provide authentication credentials. #SoupSession connects to this signal and emits its own #SoupSession::authenticate signal when it is emitted, so you shouldn't need to use this signal directly. the #SoupMessage being sent the #SoupAuth to authenticate %TRUE if this is the second (or later) attempt Indicates whether libsoup was built with GSSAPI support. If this is %FALSE, %SOUP_TYPE_AUTH_NEGOTIATE will still be defined and can still be added to a #SoupSession, but libsoup will never attempt to actually use this auth type. A data buffer, generally used to represent a chunk of a #SoupMessageBody. @data is a #char because that's generally convenient; in some situations you may need to cast it to #guchar or another type. the data length of @data Creates a new #SoupBuffer containing @length bytes from @data. the new #SoupBuffer. how @data is to be used by the buffer data length of @data Creates a new #SoupBuffer containing @length bytes from @data. This function is exactly equivalent to soup_buffer_new() with %SOUP_MEMORY_TAKE as first argument; it exists mainly for convenience and simplifying language bindings. the new #SoupBuffer. data length of @data Creates a new #SoupBuffer containing @length bytes from @data. When the #SoupBuffer is freed, it will call @owner_dnotify, passing @owner to it. You must ensure that @data will remain valid until @owner_dnotify is called. For example, you could use this to create a buffer containing data returned from libxml without needing to do an extra copy: <informalexample><programlisting> xmlDocDumpMemory (doc, &xmlbody, &len); return soup_buffer_new_with_owner (xmlbody, len, xmlbody, (GDestroyNotify)xmlFree); </programlisting></informalexample> In this example, @data and @owner are the same, but in other cases they would be different (eg, @owner would be a object, and @data would be a pointer to one of the object's fields). the new #SoupBuffer. data length of @data pointer to an object that owns @data a function to free/unref @owner when the buffer is freed Makes a copy of @buffer. In reality, #SoupBuffer is a refcounted type, and calling soup_buffer_copy() will normally just increment the refcount on @buffer and return it. However, if @buffer was created with #SOUP_MEMORY_TEMPORARY memory, then soup_buffer_copy() will actually return a copy of it, so that the data in the copy will remain valid after the temporary buffer is freed. the new (or newly-reffed) buffer a #SoupBuffer Frees @buffer. (In reality, as described in the documentation for soup_buffer_copy(), this is actually an "unref" operation, and may or may not actually free @buffer.) a #SoupBuffer Creates a #GBytes pointing to the same memory as @buffer. The #GBytes will hold a reference on @buffer to ensure that it is not freed while the #GBytes is still valid. a new #GBytes which has the same content as the #SoupBuffer. a #SoupBuffer This function exists for use by language bindings, because it's not currently possible to get the right effect by annotating the fields of #SoupBuffer. a #SoupBuffer the pointer to the buffer data is stored here the length of the buffer data is stored here Gets the "owner" object for a buffer created with soup_buffer_new_with_owner(). the owner pointer a #SoupBuffer created with soup_buffer_new_with_owner() Creates a new #SoupBuffer containing @length bytes "copied" from @parent starting at @offset. (Normally this will not actually copy any data, but will instead simply reference the same data as @parent does.) the new #SoupBuffer. the parent #SoupBuffer offset within @parent to start at number of bytes to copy from @parent Macro to test the version of libsoup being compiled against. major version (e.g. 2 for version 2.42.0) minor version (e.g. 42 for version 2.42.0) micro version (e.g. 0 for version 2.42.0) Alias for the #SoupCookieJar:accept-policy property. Alias for the #SoupCookieJarDB:filename property. (The cookie-storage filename.) Alias for the #SoupCookieJar:read-only property. (Whether or not the cookie jar is read-only.) Alias for the #SoupCookieJarText:filename property. (The cookie-storage filename.) A constant corresponding to 1 day, for use with soup_cookie_new() and soup_cookie_set_max_age(). A constant corresponding to 1 hour, for use with soup_cookie_new() and soup_cookie_set_max_age(). A constant corresponding to 1 week, for use with soup_cookie_new() and soup_cookie_set_max_age(). A constant corresponding to 1 year, for use with soup_cookie_new() and soup_cookie_set_max_age(). Creates a new #SoupCache. a new #SoupCache the directory to store the cached data, or %NULL to use the default one. Note that since the cache isn't safe to access for multiple processes at once, and the default directory isn't namespaced by process, clients are strongly discouraged from passing %NULL. the #SoupCacheType of the cache Will remove all entries in the @cache plus all the cache files. a #SoupCache Synchronously writes the cache index out to disk. Contrast with soup_cache_flush(), which writes pending cache <emphasis>entries</emphasis> to disk. You must call this before exiting if you want your cache data to persist between sessions. a #SoupCache This function will force all pending writes in the @cache to be committed to disk. For doing so it will iterate the #GMainContext associated with @cache's session as long as needed. Contrast with soup_cache_dump(), which writes out the cache index file. a #SoupCache Gets the maximum size of the cache. the maximum size of the cache, in bytes. a #SoupCache Loads the contents of @cache's index into memory. a #SoupCache Sets the maximum size of the cache. a #SoupCache the maximum size of the cache, in bytes The type of cache; this affects what kinds of responses will be saved. a single-user cache a shared cache The prototype for a chunk allocation callback. This should allocate a new #SoupBuffer and return it for the I/O layer to read message body data off the network into. If @max_len is non-0, it indicates the maximum number of bytes that could be read, based on what is known about the message size. Note that this might be a very large number, and you should not simply try to allocate that many bytes blindly. If @max_len is 0, that means that libsoup does not know how many bytes remain to be read, and the allocator should return a buffer of a size that it finds convenient. If the allocator returns %NULL, the message will be paused. It is up to the application to make sure that it gets unpaused when it becomes possible to allocate a new buffer. Use #SoupRequest if you want to read into your own buffers. the new buffer (or %NULL) the #SoupMessage the chunk is being allocated for the maximum length that will be read, or 0. the data passed to soup_message_set_chunk_allocator() A #SoupClientContext provides additional information about the client making a particular request. In particular, you can use soup_client_context_get_auth_domain() and soup_client_context_get_auth_user() to determine if HTTP authentication was used successfully. soup_client_context_get_remote_address() and/or soup_client_context_get_host() can be used to get information for logging or debugging purposes. soup_client_context_get_gsocket() may also be of use in some situations (eg, tracking when multiple requests are made on the same connection). Retrieves the #SoupAddress associated with the remote end of a connection. Use soup_client_context_get_remote_address(), which returns a #GSocketAddress. the #SoupAddress associated with the remote end of a connection, it may be %NULL if you used soup_server_accept_iostream(). a #SoupClientContext Checks whether the request associated with @client has been authenticated, and if so returns the #SoupAuthDomain that authenticated it. a #SoupAuthDomain, or %NULL if the request was not authenticated. a #SoupClientContext Checks whether the request associated with @client has been authenticated, and if so returns the username that the client authenticated as. the authenticated-as user, or %NULL if the request was not authenticated. a #SoupClientContext Retrieves the #GSocket that @client is associated with. If you are using this method to observe when multiple requests are made on the same persistent HTTP connection (eg, as the ntlm-test test program does), you will need to pay attention to socket destruction as well (eg, by using weak references), so that you do not get fooled when the allocator reuses the memory address of a previously-destroyed socket to represent a new socket. the #GSocket that @client is associated with, %NULL if you used soup_server_accept_iostream(). a #SoupClientContext Retrieves the IP address associated with the remote end of a connection. the IP address associated with the remote end of a connection, it may be %NULL if you used soup_server_accept_iostream(). a #SoupClientContext Retrieves the #GSocketAddress associated with the local end of a connection. the #GSocketAddress associated with the local end of a connection, it may be %NULL if you used soup_server_accept_iostream(). a #SoupClientContext Retrieves the #GSocketAddress associated with the remote end of a connection. the #GSocketAddress associated with the remote end of a connection, it may be %NULL if you used soup_server_accept_iostream(). a #SoupClientContext Retrieves the #SoupSocket that @client is associated with. If you are using this method to observe when multiple requests are made on the same persistent HTTP connection (eg, as the ntlm-test test program does), you will need to pay attention to socket destruction as well (either by using weak references, or by connecting to the #SoupSocket::disconnected signal), so that you do not get fooled when the allocator reuses the memory address of a previously-destroyed socket to represent a new socket. use soup_client_context_get_gsocket(), which returns a #GSocket. the #SoupSocket that @client is associated with. a #SoupClientContext "Steals" the HTTP connection associated with @client from its #SoupServer. This happens immediately, regardless of the current state of the connection; if the response to the current #SoupMessage has not yet finished being sent, then it will be discarded; you can steal the connection from a #SoupMessage:wrote-informational or #SoupMessage:wrote-body signal handler if you need to wait for part or all of the response to be sent. Note that when calling this function from C, @client will most likely be freed as a side effect. the #GIOStream formerly associated with @client (or %NULL if @client was no longer associated with a connection). No guarantees are made about what kind of #GIOStream is returned. a #SoupClientContext Creates a new #SoupContentSniffer. a new #SoupContentSniffer Gets the number of bytes @sniffer needs in order to properly sniff a buffer. the number of bytes to sniff a #SoupContentSniffer Sniffs @buffer to determine its Content-Type. The result may also be influenced by the Content-Type declared in @msg's response headers. the sniffed Content-Type of @buffer; this will never be %NULL, but may be "application/octet-stream". a #SoupContentSniffer the message to sniff a buffer containing the start of @msg's response body return location for Content-Type parameters (eg, "charset"), or %NULL Gets the number of bytes @sniffer needs in order to properly sniff a buffer. the number of bytes to sniff a #SoupContentSniffer Sniffs @buffer to determine its Content-Type. The result may also be influenced by the Content-Type declared in @msg's response headers. the sniffed Content-Type of @buffer; this will never be %NULL, but may be "application/octet-stream". a #SoupContentSniffer the message to sniff a buffer containing the start of @msg's response body return location for Content-Type parameters (eg, "charset"), or %NULL the sniffed Content-Type of @buffer; this will never be %NULL, but may be "application/octet-stream". a #SoupContentSniffer the message to sniff a buffer containing the start of @msg's response body return location for Content-Type parameters (eg, "charset"), or %NULL the number of bytes to sniff a #SoupContentSniffer An HTTP cookie. @name and @value will be set for all cookies. If the cookie is generated from a string that appears to have no name, then @name will be the empty string. @domain and @path give the host or domain, and path within that host/domain, to restrict this cookie to. If @domain starts with ".", that indicates a domain (which matches the string after the ".", or any hostname that has @domain as a suffix). Otherwise, it is a hostname and must match exactly. @expires will be non-%NULL if the cookie uses either the original "expires" attribute, or the newer "max-age" attribute. If @expires is %NULL, it indicates that neither "expires" nor "max-age" was specified, and the cookie expires at the end of the session. If @http_only is set, the cookie should not be exposed to untrusted code (eg, javascript), so as to minimize the danger posed by cross-site scripting attacks. the cookie name the cookie value the "domain" attribute, or else the hostname that the cookie came from. the "path" attribute, or %NULL the cookie expiration time, or %NULL for a session cookie %TRUE if the cookie should only be tranferred over SSL %TRUE if the cookie should not be exposed to scripts Creates a new #SoupCookie with the given attributes. (Use soup_cookie_set_secure() and soup_cookie_set_http_only() if you need to set those attributes on the returned cookie.) If @domain starts with ".", that indicates a domain (which matches the string after the ".", or any hostname that has @domain as a suffix). Otherwise, it is a hostname and must match exactly. @max_age is used to set the "expires" attribute on the cookie; pass -1 to not include the attribute (indicating that the cookie expires with the current session), 0 for an already-expired cookie, or a lifetime in seconds. You can use the constants %SOUP_COOKIE_MAX_AGE_ONE_HOUR, %SOUP_COOKIE_MAX_AGE_ONE_DAY, %SOUP_COOKIE_MAX_AGE_ONE_WEEK and %SOUP_COOKIE_MAX_AGE_ONE_YEAR (or multiples thereof) to calculate this value. (If you really care about setting the exact time that the cookie will expire, use soup_cookie_set_expires().) a new #SoupCookie. cookie name cookie value cookie domain or hostname cookie path, or %NULL max age of the cookie, or -1 for a session cookie Tests if @cookie should be sent to @uri. (At the moment, this does not check that @cookie's domain matches @uri, because it assumes that the caller has already done that. But don't rely on that; it may change in the future.) %TRUE if @cookie should be sent to @uri, %FALSE if not a #SoupCookie a #SoupURI Copies @cookie. a copy of @cookie a #SoupCookie Checks if the @cookie's domain and @host match in the sense that @cookie should be sent when making a request to @host, or that @cookie should be accepted when receiving a response from @host. %TRUE if the domains match, %FALSE otherwise a #SoupCookie a URI Tests if @cookie1 and @cookie2 are equal. Note that currently, this does not check that the cookie domains match. This may change in the future. whether the cookies are equal. a #SoupCookie a #SoupCookie Frees @cookie a #SoupCookie Gets @cookie's domain @cookie's domain a #SoupCookie Gets @cookie's expiration time. @cookie's expiration time, which is owned by @cookie and should not be modified or freed. a #SoupCookie Gets @cookie's HttpOnly attribute @cookie's HttpOnly attribute a #SoupCookie Gets @cookie's name @cookie's name a #SoupCookie Gets @cookie's path @cookie's path a #SoupCookie a #SoupSameSitePolicy a #SoupCookie Gets @cookie's secure attribute @cookie's secure attribute a #SoupCookie Gets @cookie's value @cookie's value a #SoupCookie Sets @cookie's domain to @domain a #SoupCookie the new domain Sets @cookie's expiration time to @expires. If @expires is %NULL, @cookie will be a session cookie and will expire at the end of the client's session. (This sets the same property as soup_cookie_set_max_age().) a #SoupCookie the new expiration time, or %NULL Sets @cookie's HttpOnly attribute to @http_only. If %TRUE, @cookie will be marked as "http only", meaning it should not be exposed to web page scripts or other untrusted code. a #SoupCookie the new value for the HttpOnly attribute Sets @cookie's max age to @max_age. If @max_age is -1, the cookie is a session cookie, and will expire at the end of the client's session. Otherwise, it is the number of seconds until the cookie expires. You can use the constants %SOUP_COOKIE_MAX_AGE_ONE_HOUR, %SOUP_COOKIE_MAX_AGE_ONE_DAY, %SOUP_COOKIE_MAX_AGE_ONE_WEEK and %SOUP_COOKIE_MAX_AGE_ONE_YEAR (or multiples thereof) to calculate this value. (A value of 0 indicates that the cookie should be considered already-expired.) (This sets the same property as soup_cookie_set_expires().) a #SoupCookie the new max age Sets @cookie's name to @name a #SoupCookie the new name Sets @cookie's path to @path a #SoupCookie the new path When used in conjunction with soup_cookie_jar_get_cookie_list_with_same_site_info() this sets the policy of when this cookie should be exposed. a #SoupCookie a #SoupSameSitePolicy Sets @cookie's secure attribute to @secure. If %TRUE, @cookie will only be transmitted from the client to the server over secure (https) connections. a #SoupCookie the new value for the secure attribute Sets @cookie's value to @value a #SoupCookie the new value Serializes @cookie in the format used by the Cookie header (ie, for returning a cookie from a #SoupSession to a server). the header a #SoupCookie Serializes @cookie in the format used by the Set-Cookie header (ie, for sending a cookie from a #SoupServer to a client). the header a #SoupCookie Parses @header and returns a #SoupCookie. (If @header contains multiple cookies, only the first one will be parsed.) If @header does not have "path" or "domain" attributes, they will be defaulted from @origin. If @origin is %NULL, path will default to "/", but domain will be left as %NULL. Note that this is not a valid state for a #SoupCookie, and you will need to fill in some appropriate string for the domain if you want to actually make use of the cookie. a new #SoupCookie, or %NULL if it could not be parsed, or contained an illegal "domain" attribute for a cookie originating from @origin. a cookie string (eg, the value of a Set-Cookie header) origin of the cookie, or %NULL Creates a new #SoupCookieJar. The base #SoupCookieJar class does not support persistent storage of cookies; use a subclass for that. a new #SoupCookieJar Gets whether @jar stores cookies persistenly. %TRUE if @jar storage is persistent or %FALSE otherwise. a #SoupCookieJar This function exists for backward compatibility, but does not do anything any more; cookie jars are saved automatically when they are changed. This is a no-op. a #SoupCookieJar Adds @cookie to @jar, emitting the 'changed' signal if we are modifying an existing cookie or adding a valid new cookie ('valid' means that the cookie's expire date is not in the past). @cookie will be 'stolen' by the jar, so don't free it afterwards. a #SoupCookieJar a #SoupCookie Adds @cookie to @jar, emitting the 'changed' signal if we are modifying an existing cookie or adding a valid new cookie ('valid' means that the cookie's expire date is not in the past). @first_party will be used to reject cookies coming from third party resources in case such a security policy is set in the @jar. @uri will be used to reject setting or overwriting secure cookies from insecure origins. %NULL is treated as secure. @cookie will be 'stolen' by the jar, so don't free it afterwards. a #SoupCookieJar a #SoupCookie the URI setting the cookie the URI for the main document Adds @cookie to @jar, emitting the 'changed' signal if we are modifying an existing cookie or adding a valid new cookie ('valid' means that the cookie's expire date is not in the past). @first_party will be used to reject cookies coming from third party resources in case such a security policy is set in the @jar. @cookie will be 'stolen' by the jar, so don't free it afterwards. For secure cookies to work properly you may want to use soup_cookie_jar_add_cookie_full(). a #SoupCookieJar the URI for the main document a #SoupCookie Constructs a #GSList with every cookie inside the @jar. The cookies in the list are a copy of the original, so you have to free them when you are done with them. a #GSList with all the cookies in the @jar. a #SoupCookieJar Deletes @cookie from @jar, emitting the 'changed' signal. a #SoupCookieJar a #SoupCookie Gets @jar's #SoupCookieJarAcceptPolicy the #SoupCookieJarAcceptPolicy set in the @jar a #SoupCookieJar Retrieves the list of cookies that would be sent with a request to @uri as a #GSList of #SoupCookie objects. If @for_http is %TRUE, the return value will include cookies marked "HttpOnly" (that is, cookies that the server wishes to keep hidden from client-side scripting operations such as the JavaScript document.cookies property). Since #SoupCookieJar sets the Cookie header itself when making the actual HTTP request, you should almost certainly be setting @for_http to %FALSE if you are calling this. a #GSList with the cookies in the @jar that would be sent with a request to @uri. a #SoupCookieJar a #SoupURI whether or not the return value is being passed directly to an HTTP operation This is an extended version of soup_cookie_jar_get_cookie_list() that provides more information required to use SameSite cookies. See the [SameSite cookies spec](https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00) for more detailed information. a #GSList with the cookies in the @jar that would be sent with a request to @uri. a #SoupCookieJar a #SoupURI a #SoupURI for the top level document a #SoupURI indicating the origin to get cookies for whether or not the return value is being passed directly to an HTTP operation if the HTTP method is safe, as defined by RFC 7231, ignored when @for_http is %FALSE whether or not the HTTP request is part of top level navigation Retrieves (in Cookie-header form) the list of cookies that would be sent with a request to @uri. If @for_http is %TRUE, the return value will include cookies marked "HttpOnly" (that is, cookies that the server wishes to keep hidden from client-side scripting operations such as the JavaScript document.cookies property). Since #SoupCookieJar sets the Cookie header itself when making the actual HTTP request, you should almost certainly be setting @for_http to %FALSE if you are calling this. the cookies, in string form, or %NULL if there are no cookies for @uri. a #SoupCookieJar a #SoupURI whether or not the return value is being passed directly to an HTTP operation Gets whether @jar stores cookies persistenly. %TRUE if @jar storage is persistent or %FALSE otherwise. a #SoupCookieJar This function exists for backward compatibility, but does not do anything any more; cookie jars are saved automatically when they are changed. This is a no-op. a #SoupCookieJar Sets @policy as the cookie acceptance policy for @jar. a #SoupCookieJar a #SoupCookieJarAcceptPolicy Adds @cookie to @jar, exactly as though it had appeared in a Set-Cookie header returned from a request to @uri. Keep in mind that if the #SoupCookieJarAcceptPolicy set is either %SOUP_COOKIE_JAR_ACCEPT_NO_THIRD_PARTY or %SOUP_COOKIE_JAR_ACCEPT_GRANDFATHERED_THIRD_PARTY you'll need to use soup_cookie_jar_set_cookie_with_first_party(), otherwise the jar will have no way of knowing if the cookie is being set by a third party or not. a #SoupCookieJar the URI setting the cookie the stringified cookie to set Adds @cookie to @jar, exactly as though it had appeared in a Set-Cookie header returned from a request to @uri. @first_party will be used to reject cookies coming from third party resources in case such a security policy is set in the @jar. a #SoupCookieJar the URI setting the cookie the URI for the main document the stringified cookie to set The policy the jar should follow to accept or reject cookies Emitted when @jar changes. If a cookie has been added, @new_cookie will contain the newly-added cookie and @old_cookie will be %NULL. If a cookie has been deleted, @old_cookie will contain the to-be-deleted cookie and @new_cookie will be %NULL. If a cookie has been changed, @old_cookie will contain its old value, and @new_cookie its new value. the old #SoupCookie value the new #SoupCookie value The policy for accepting or rejecting cookies returned in responses. accept all cookies unconditionally. reject all cookies unconditionally. accept all cookies set by the main document loaded in the application using libsoup. An example of the most common case, web browsers, would be: If http://www.example.com is the page loaded, accept all cookies set by example.com, but if a resource from http://www.third-party.com is loaded from that page reject any cookie that it could try to set. For libsoup to be able to tell apart first party cookies from the rest, the application must call soup_message_set_first_party() on each outgoing #SoupMessage, setting the #SoupURI of the main document. If no first party is set in a message when this policy is in effect, cookies will be assumed to be third party by default. accept all cookies set by the main document loaded in the application using libsoup, and from domains that have previously set at least one cookie when loaded as the main document. An example of the most common case, web browsers, would be: if http://www.example.com is the page loaded, accept all cookies set by example.com, but if a resource from http://www.third-party.com is loaded from that page, reject any cookie that it could try to set unless it already has a cookie in the cookie jar. For libsoup to be able to tell apart first party cookies from the rest, the application must call soup_message_set_first_party() on each outgoing #SoupMessage, setting the #SoupURI of the main document. If no first party is set in a message when this policy is in effect, cookies will be assumed to be third party by default. Since 2.72. a #SoupCookieJar %TRUE if @jar storage is persistent or %FALSE otherwise. a #SoupCookieJar Creates a #SoupCookieJarDB. @filename will be read in at startup to create an initial set of cookies. If @read_only is %FALSE, then the non-session cookies will be written to @filename when the 'changed' signal is emitted from the jar. (If @read_only is %TRUE, then the cookie jar will only be used for this session, and changes made to it will be lost when the jar is destroyed.) the new #SoupCookieJar the filename to read to/write from, or %NULL %TRUE if @filename is read-only Creates a #SoupCookieJarText. @filename will be read in at startup to create an initial set of cookies. If @read_only is %FALSE, then the non-session cookies will be written to @filename when the 'changed' signal is emitted from the jar. (If @read_only is %TRUE, then the cookie jar will only be used for this session, and changes made to it will be lost when the jar is destroyed.) the new #SoupCookieJar the filename to read to/write from %TRUE if @filename is read-only A date and time. The date is assumed to be in the (proleptic) Gregorian calendar. The time is in UTC if @utc is %TRUE. Otherwise, the time is a local time, and @offset gives the offset from UTC in minutes (such that adding @offset to the time would give the correct UTC time). If @utc is %FALSE and @offset is 0, then the %SoupDate represents a "floating" time with no associated timezone information. the year, 1 to 9999 the month, 1 to 12 day of the month, 1 to 31 hour of the day, 0 to 23 minute, 0 to 59 second, 0 to 59 (or up to 61 in the case of leap seconds) %TRUE if the date is in UTC offset from UTC Creates a #SoupDate representing the indicated time, UTC. a new #SoupDate the year (1-9999) the month (1-12) the day of the month (1-31, as appropriate for @month) the hour (0-23) the minute (0-59) the second (0-59, or up to 61 for leap seconds) Creates a #SoupDate representing a time @offset_seconds after the current time (or before it, if @offset_seconds is negative). If offset_seconds is 0, returns the current time. If @offset_seconds would indicate a time not expressible as a <type>time_t</type>, the return value will be clamped into range. a new #SoupDate offset from current time Parses @date_string and tries to extract a date from it. This recognizes all of the "HTTP-date" formats from RFC 2616, all ISO 8601 formats containing both a time and a date, RFC 2822 dates, and reasonable approximations thereof. (Eg, it is lenient about whitespace, leading "0"s, etc.) a new #SoupDate, or %NULL if @date_string could not be parsed. the date in some plausible format Creates a #SoupDate corresponding to @when a new #SoupDate a <type>time_t</type> Copies @date. a #SoupDate Frees @date. a #SoupDate Gets @date's day. @date's day a #SoupDate Gets @date's hour. @date's hour a #SoupDate Gets @date's minute. @date's minute a #SoupDate Gets @date's month. @date's month a #SoupDate Gets @date's offset from UTC. @date's offset from UTC. If soup_date_get_utc() returns %FALSE but soup_date_get_offset() returns 0, that means the date is a "floating" time with no associated offset information. a #SoupDate Gets @date's second. @date's second a #SoupDate Gets @date's UTC flag %TRUE if @date is UTC. a #SoupDate Gets @date's year. @date's year a #SoupDate Determines if @date is in the past. %TRUE if @date is in the past a #SoupDate Converts @date to a string in the format described by @format. @date as a string a #SoupDate the format to generate the date in Converts @date to a <type>time_t</type>, assumming it to be in UTC. If @date is not representable as a <type>time_t</type>, it will be clamped into range. (In particular, some HTTP cookies have expiration dates after "Y2.038k" (2038-01-19T03:14:07Z).) @date as a <type>time_t</type> a #SoupDate Converts @date to a #GTimeVal. Do not use #GTimeVal, as it's not Y2038-safe. a #SoupDate a #GTimeVal structure in which to store the converted time. Date formats that soup_date_to_string() can use. @SOUP_DATE_HTTP and @SOUP_DATE_COOKIE always coerce the time to UTC. @SOUP_DATE_ISO8601_XMLRPC uses the time as given, ignoring the offset completely. @SOUP_DATE_RFC2822 and the other ISO 8601 variants use the local time, appending the offset information if available. This enum may be extended with more values in future releases. RFC 1123 format, used by the HTTP "Date" header. Eg "Sun, 06 Nov 1994 08:49:37 GMT" The format for the "Expires" timestamp in the Netscape cookie specification. Eg, "Sun, 06-Nov-1994 08:49:37 GMT". RFC 2822 format, eg "Sun, 6 Nov 1994 09:49:37 -0100" ISO 8601 date/time with no optional punctuation. Eg, "19941106T094937-0100". ISO 8601 date/time with all optional punctuation. Eg, "1994-11-06T09:49:37-01:00". An alias for @SOUP_DATE_ISO8601_FULL. ISO 8601 date/time as used by XML-RPC. Eg, "19941106T09:49:37". How a message body is encoded for transport unknown / error no body is present (which is not the same as a 0-length body, and only occurs in certain places) Content-Length encoding Response body ends when the connection is closed chunked encoding (currently only supported for response) multipart/byteranges (Reserved for future use: NOT CURRENTLY IMPLEMENTED) Represents the parsed value of the "Expect" header. any unrecognized expectation "100-continue" A macro containing the value <literal>"multipart/form-data"</literal>; the MIME type used for posting form data that contains files to be uploaded. A macro containing the value <literal>"application/x-www-form-urlencoded"</literal>; the default MIME type for POSTing HTML form data. Creates a new #SoupHSTSEnforcer. The base #SoupHSTSEnforcer class does not support persistent storage of HSTS policies, see #SoupHSTSEnforcerDB for that. a new #SoupHSTSEnforcer Gets whether @hsts_enforcer has a currently valid policy for @domain. %TRUE if access to @domain should happen over HTTPS, false otherwise. a #SoupHSTSEnforcer a domain. Gets whether @hsts_enforcer stores policies persistenly. %TRUE if @hsts_enforcer storage is persistent or %FALSE otherwise. a #SoupHSTSEnforcer Gets a list of domains for which there are policies in @enforcer. a newly allocated list of domains. Use g_list_free_full() and g_free() to free the list. a #SoupHSTSEnforcer whether to include session policies Gets a list with the policies in @enforcer. a newly allocated list of policies. Use g_list_free_full() and soup_hsts_policy_free() to free the list. a #SoupHSTSEnforcer whether to include session policies Gets whether @hsts_enforcer has a currently valid policy for @domain. %TRUE if access to @domain should happen over HTTPS, false otherwise. a #SoupHSTSEnforcer a domain. Gets whether @hsts_enforcer stores policies persistenly. %TRUE if @hsts_enforcer storage is persistent or %FALSE otherwise. a #SoupHSTSEnforcer Sets @policy to @hsts_enforcer. If @policy is expired, any existing HSTS policy for its host will be removed instead. If a policy existed for this host, it will be replaced. Otherwise, the new policy will be inserted. If the policy is a session policy, that is, one created with soup_hsts_policy_new_session_policy(), the policy will not expire and will be enforced during the lifetime of @hsts_enforcer's #SoupSession. a #SoupHSTSEnforcer the policy of the HSTS host Sets a session policy for @domain. A session policy is a policy that is permanent to the lifetime of @hsts_enforcer's #SoupSession and doesn't expire. a #SoupHSTSEnforcer policy domain or hostname %TRUE if the policy applies on sub domains Emitted when @hsts_enforcer changes. If a policy has been added, @new_policy will contain the newly-added policy and @old_policy will be %NULL. If a policy has been deleted, @old_policy will contain the to-be-deleted policy and @new_policy will be %NULL. If a policy has been changed, @old_policy will contain its old value, and @new_policy its new value. Note that you shouldn't modify the policies from a callback to this signal. the old #SoupHSTSPolicy value the new #SoupHSTSPolicy value Emitted when @hsts_enforcer has upgraded the protocol for @message to HTTPS as a result of matching its domain with a HSTS policy. the message for which HSTS is being enforced The parent class. %TRUE if @hsts_enforcer storage is persistent or %FALSE otherwise. a #SoupHSTSEnforcer %TRUE if access to @domain should happen over HTTPS, false otherwise. a #SoupHSTSEnforcer a domain. Creates a #SoupHSTSEnforcerDB. @filename will be read in during the initialization of a #SoupHSTSEnforcerDB, in order to create an initial set of HSTS policies. If the file doesn't exist, a new database will be created and initialized. Changes to the policies during the lifetime of a #SoupHSTSEnforcerDB will be written to @filename when #SoupHSTSEnforcer::changed is emitted. the new #SoupHSTSEnforcer the filename of the database to read/write from. The filename of the SQLite database where HSTS policies are stored. An HTTP Strict Transport Security policy. @domain represents the host that this policy applies to. The domain must be IDNA-canonicalized. soup_hsts_policy_new() and related methods will do this for you. @max_age contains the 'max-age' value from the Strict Transport Security header and indicates the time to live of this policy, in seconds. @expires will be non-%NULL if the policy has been set by the host and hence has an expiry time. If @expires is %NULL, it indicates that the policy is a permanent session policy set by the user agent. If @include_subdomains is %TRUE, the Strict Transport Security policy must also be enforced on subdomains of @domain. The domain or hostname that the policy applies to The maximum age, in seconds, that the policy is valid the policy expiration time, or %NULL for a permanent session policy %TRUE if the policy applies on subdomains Creates a new #SoupHSTSPolicy with the given attributes. @domain is a domain on which the strict transport security policy represented by this object must be enforced. @max_age is used to set the "expires" attribute on the policy; pass SOUP_HSTS_POLICY_MAX_AGE_PAST for an already-expired policy, or a lifetime in seconds. If @include_subdomains is %TRUE, the strict transport security policy must also be enforced on all subdomains of @domain. a new #SoupHSTSPolicy. policy domain or hostname max age of the policy %TRUE if the policy applies on subdomains Parses @msg's first "Strict-Transport-Security" response header and returns a #SoupHSTSPolicy. a new #SoupHSTSPolicy, or %NULL if no valid "Strict-Transport-Security" response header was found. a #SoupMessage Full version of #soup_hsts_policy_new(), to use with an existing expiration date. See #soup_hsts_policy_new() for details. a new #SoupHSTSPolicy. policy domain or hostname max age of the policy the date of expiration of the policy or %NULL for a permanent policy %TRUE if the policy applies on subdomains Creates a new session #SoupHSTSPolicy with the given attributes. A session policy is a policy that is valid during the lifetime of the #SoupHSTSEnforcer it is added to. Contrary to regular policies, it has no expiration date and is not stored in persistent enforcers. These policies are useful for user-agent to load their own or user-defined rules. @domain is a domain on which the strict transport security policy represented by this object must be enforced. If @include_subdomains is %TRUE, the strict transport security policy must also be enforced on all subdomains of @domain. a new #SoupHSTSPolicy. policy domain or hostname %TRUE if the policy applies on sub domains Copies @policy. a copy of @policy a #SoupHSTSPolicy Tests if @policy1 and @policy2 are equal. whether the policies are equal. a #SoupHSTSPolicy a #SoupHSTSPolicy Frees @policy. a #SoupHSTSPolicy Gets @policy's domain. @policy's domain. a #SoupHSTSPolicy Gets whether @policy include its subdomains. %TRUE if @policy includes subdomains, %FALSE otherwise. a #SoupHSTSPolicy Gets whether @policy is expired. Permanent policies never expire. %TRUE if @policy is expired, %FALSE otherwise. a #SoupHSTSPolicy Gets whether @policy is a non-permanent, non-expirable session policy. see soup_hsts_policy_new_session_policy() for details. %TRUE if @policy is permanent, %FALSE otherwise a #SoupHSTSPolicy Indicates the HTTP protocol version being used. HTTP 1.0 (RFC 1945) HTTP 1.1 (RFC 2616) Alias for the #SoupLogger:level property, qv. Alias for the #SoupLogger:max-body-size property, qv. Creates a new #SoupLogger with the given debug level. If @level is %SOUP_LOGGER_LOG_BODY, @max_body_size gives the maximum number of bytes of the body that will be logged. (-1 means "no limit".) If you need finer control over what message parts are and aren't logged, use soup_logger_set_request_filter() and soup_logger_set_response_filter(). a new #SoupLogger the debug level the maximum body size to output, or -1 Sets @logger to watch @session and print debug information for its messages. (The session will take a reference on @logger, which will be removed when you call soup_logger_detach(), or when the session is destroyed.) Use soup_session_add_feature() instead. a #SoupLogger a #SoupSession Stops @logger from watching @session. Use soup_session_remove_feature() instead. a #SoupLogger a #SoupSession Sets up an alternate log printing routine, if you don't want the log to go to <literal>stdout</literal>. a #SoupLogger the callback for printing logging output data to pass to the callback a #GDestroyNotify to free @printer_data Sets up a filter to determine the log level for a given request. For each HTTP request @logger will invoke @request_filter to determine how much (if any) of that request to log. (If you do not set a request filter, @logger will just always log requests at the level passed to soup_logger_new().) a #SoupLogger the callback for request debugging data to pass to the callback a #GDestroyNotify to free @filter_data Sets up a filter to determine the log level for a given response. For each HTTP response @logger will invoke @response_filter to determine how much (if any) of that response to log. (If you do not set a response filter, @logger will just always log responses at the level passed to soup_logger_new().) a #SoupLogger the callback for response debugging data to pass to the callback a #GDestroyNotify to free @filter_data The level of logging output If #SoupLogger:level is %SOUP_LOGGER_LOG_BODY, this gives the maximum number of bytes of the body that will be logged. (-1 means "no limit".) The prototype for a logging filter. The filter callback will be invoked for each request or response, and should analyze it and return a #SoupLoggerLogLevel value indicating how much of the message to log. Eg, it might choose between %SOUP_LOGGER_LOG_BODY and %SOUP_LOGGER_LOG_HEADERS depending on the Content-Type. a #SoupLoggerLogLevel value indicating how much of the message to log the #SoupLogger the message being logged the data passed to soup_logger_set_request_filter() or soup_logger_set_response_filter() Describes the level of logging output to provide. No logging Log the Request-Line or Status-Line and the Soup-Debug pseudo-headers Log the full request/response headers Log the full headers and request/response bodies. The prototype for a custom printing callback. @level indicates what kind of information is being printed. Eg, it will be %SOUP_LOGGER_LOG_HEADERS if @data is header data. @direction is either '<', '>', or ' ', and @data is the single line to print; the printer is expected to add a terminating newline. To get the effect of the default printer, you would do: <informalexample><programlisting> printf ("%c %s\n", direction, data); </programlisting></informalexample> the #SoupLogger the level of the information being printed. a single-character prefix to @data data to print the data passed to soup_logger_set_printer() Like soup_get_major_version(), but from the headers used at application compile time, rather than from the library linked against at application run time. Alias for the #SoupMessage:first-party property. (The #SoupURI loaded in the application when the message was queued.) Alias for the #SoupMessage:flags property. (The message's #SoupMessageFlags.) Alias for the #SoupMessage:http-version property. (The message's #SoupHTTPVersion.) Alias for the #SoupMessage:method property. (The message's HTTP method.) Sets the priority of the #SoupMessage. See soup_message_set_priority() for further details. Alias for the #SoupMessage:reason-phrase property. (The message's HTTP response reason phrase.) Alias for the #SoupMessage:request-body property. (The message's HTTP request body.) Alias for the #SoupMessage:request-body-data property. (The message's HTTP request body, as a #GBytes.) Alias for the #SoupMessage:request-headers property. (The message's HTTP request headers.) Alias for the #SoupMessage:response-body property. (The message's HTTP response body.) Alias for the #SoupMessage:response-body-data property. (The message's HTTP response body, as a #GBytes.) Alias for the #SoupMessage:response-headers property. (The message's HTTP response headers.) Alias for the #SoupMessage:server-side property. (%TRUE if the message was created by #SoupServer.) Alias for the #SoupMessage:status-code property. (The message's HTTP response status code.) Alias for the #SoupMessage:tls-certificate property. (The TLS certificate associated with the message, if any.) Alias for the #SoupMessage:tls-errors property. (The verification errors on #SoupMessage:tls-certificate.) Alias for the #SoupMessage:uri property. (The message's #SoupURI.) Like soup_get_micro_version(), but from the headers used at application compile time, rather than from the library linked against at application run time. Like soup_get_minor_version(), but from the headers used at application compile time, rather than from the library linked against at application run time. Describes how #SoupBuffer should use the data passed in by the caller. See also soup_buffer_new_with_owner(), which allows to you create a buffer containing data which is owned by another object. The memory is statically allocated and constant; libsoup can use the passed-in buffer directly and not need to worry about it being modified or freed. The caller has allocated the memory for the #SoupBuffer's use; libsoup will assume ownership of it and free it (with g_free()) when it is done with it. The passed-in data belongs to the caller; the #SoupBuffer will copy it into new memory, leaving the caller free to reuse the original memory. The passed-in data belongs to the caller, but will remain valid for the lifetime of the #SoupBuffer. The difference between this and @SOUP_MEMORY_STATIC is that if you copy a @SOUP_MEMORY_TEMPORARY buffer, it will make a copy of the memory as well, rather than reusing the original memory. Represents an HTTP message being sent or received. @status_code will normally be a #SoupStatus value, eg, %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 @request_body and @response_body <literal>data</literal> fields will not necessarily be filled in at all times. When the body fields are filled in, they will be terminated with a '\0' byte (which is not included in the <literal>length</literal>), 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 <literal>data</literal> 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 <literal>data</literal> is filled in. If you are not using #SoupRequest to read the response, then @response_body's <literal>data</literal> will be filled in before #SoupMessage::finished is emitted. (If you are using #SoupRequest, then the message body is not accumulated by default, so @response_body's <literal>data</literal> will always be %NULL.) 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 @request_body as appropriate, passing %FALSE. Creates a new empty #SoupMessage, which will connect to @uri the new #SoupMessage (or %NULL if @uri could not be parsed). the HTTP method for the created request the destination endpoint (as a string) Creates a new empty #SoupMessage, which will connect to @uri the new #SoupMessage the HTTP method for the created request the destination endpoint (as a #SoupURI) Adds a signal handler to @msg for @signal, as with g_signal_connect(), but the @callback will only be run if @msg's incoming messages headers (that is, the <literal>request_headers</literal> for a client #SoupMessage, or the <literal>response_headers</literal> for a server #SoupMessage) contain a header named @header. the handler ID from g_signal_connect() a #SoupMessage signal to connect the handler to. HTTP response header to match against the header handler data to pass to @handler_cb Adds a signal handler to @msg for @signal, as with g_signal_connect(), but the @callback will only be run if @msg has the status @status_code. @signal must be a signal that will be emitted after @msg's status 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. the handler ID from g_signal_connect() a #SoupMessage signal to connect the handler to. status code to match against the header handler data to pass to @handler_cb This disables the actions of #SoupSessionFeature<!-- -->s 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_CONTENT_SNIFFER for @feature_type will disable Content-Type sniffing on the message. 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. a #SoupMessage the #GType of a #SoupSessionFeature 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. the address @msg's URI points to a #SoupMessage Gets @msg's first-party #SoupURI the @msg's first party #SoupURI a #SoupMessage Gets the flags on @msg the flags a #SoupMessage Gets the HTTP version of @msg. This is the minimum of the version from the request and the version from the response. the HTTP version a #SoupMessage If @msg is using https (or attempted to use https but got %SOUP_STATUS_SSL_FAILED), this retrieves the #GTlsCertificate associated with its connection, and the #GTlsCertificateFlags showing what problems, if any, have been found with that certificate. <note><para>This is only meaningful with messages processed by a #SoupSession and is not useful for messages received by a #SoupServer</para></note> %TRUE if @msg used/attempted https, %FALSE if not a #SoupMessage @msg's TLS certificate the verification status of @certificate a #SoupMessage Retrieves the #SoupMessagePriority. If not set this value defaults to #SOUP_MESSAGE_PRIORITY_NORMAL. the priority of the message. a #SoupMessage Gets @msg's site for cookies #SoupURI the @msg's site for cookies #SoupURI a #SoupMessage If @msg is associated with a #SoupRequest, this returns that request. Otherwise it returns %NULL. @msg's associated #SoupRequest a #SoupMessage Gets @msg's URI the URI @msg is targeted for. a #SoupMessage Get whether #SoupSessionFeature<!-- -->s of the given @feature_type (or a subclass of that type) are disabled on @msg. See soup_message_disable_feature(). %TRUE if feature is disabled, or %FALSE otherwise. a #SoupMessage the #GType of a #SoupSessionFeature 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. %TRUE or %FALSE. a #SoupMessage Sets an alternate chunk-allocation function to use when reading @msg's body when using the traditional (ie, non-#SoupRequest<!-- -->-based) API. Every time data is available to read, libsoup will 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 <literal>length</literal> 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 #SoupMessage::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 #SoupMessage::got_chunk handler. The other thing to remember when using non-accumulating message bodies is that the buffer passed to the #SoupMessage::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. #SoupRequest provides a much simpler API that lets you read the response directly into your own buffers without needing to mess with callbacks, pausing/unpausing, etc. a #SoupMessage the chunk allocator callback data to pass to @allocator destroy notifier to free @user_data when @msg is destroyed 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. a #SoupMessage the #SoupURI for the @msg's first party Sets the specified flags on @msg. a #SoupMessage a set of #SoupMessageFlags values 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. a #SoupMessage the HTTP version See the [same-site spec](https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00) for more information. a #SoupMessage if %TRUE indicate the current request is a top-level navigation Sets the priority of a message. Note that this won't have any effect unless used before the message is added to the session's message processing queue. The message will be placed just before any other previously added message with lower priority (messages with the same priority are processed on a FIFO basis). Setting priorities does not currently work with #SoupSessionSync (or with synchronous messages on a plain #SoupSession) because in the synchronous/blocking case, priority ends up being determined semi-randomly by thread scheduling. a #SoupMessage the #SoupMessagePriority Sets @msg's status_code to @status_code and adds a Location header pointing to @redirect_uri. Use this from a #SoupServer when you want to redirect the client to another URI. @redirect_uri can be a relative URI, in which case it is interpreted relative to @msg's current URI. In particular, if @redirect_uri is just a path, it will replace the path <emphasis>and query</emphasis> of @msg's URI. a #SoupMessage a 3xx status code the URI to redirect @msg to Convenience function to set the request body of a #SoupMessage. If @content_type is %NULL, the request body must be empty as well. the message MIME Content-Type of the body a #SoupMemoryUse describing how to handle @req_body a data buffer containing the body of the message request. the byte length of @req_body. Convenience function to set the response body of a #SoupMessage. If @content_type is %NULL, the response body must be empty as well. the message MIME Content-Type of the body a #SoupMemoryUse describing how to handle @resp_body a data buffer containing the body of the message response. the byte length of @resp_body. Sets @site_for_cookies as the policy URL for same-site cookies for @msg. It is either the URL of the top-level document or %NULL depending on whether the registrable domain of this document's URL matches the registrable domain of its parent's/opener's URL. For the top-level document it is set to the document's URL. See the [same-site spec](https://tools.ietf.org/html/draft-ietf-httpbis-cookie-same-site-00) for more information. a #SoupMessage the #SoupURI for the @msg's site for cookies Sets @msg's status code to @status_code. If @status_code is a known value, it will also set @msg's reason_phrase. a #SoupMessage an HTTP status code Sets @msg's status code and reason phrase. a #SoupMessage an HTTP status code a description of the status 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(). a #SoupMessage the new #SoupURI The #SoupURI loaded in the application when the message was queued. Set when the message is navigating between top level domains. The message's HTTP request body, as a #GBytes. The message's HTTP response body, as a #GBytes. The #GTlsCertificate associated with the message The verification errors on #SoupMessage:tls-certificate the HTTP method the HTTP status code the status phrase associated with @status_code the request body the request headers the response body the response headers This signal is emitted after #SoupMessage::got-headers, and before the first #SoupMessage::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 #SoupMessage::got-headers, and @type is %NULL. If the #SoupContentSniffer feature is enabled, and the sniffer decided to perform sniffing, the first #SoupMessage::got-chunk emission may be delayed, so that the sniffer has enough data to correctly sniff the content. It notified the library user that the content has been sniffed, and allows it to change the header contents in the message, if desired. After this signal is emitted, the data that was spooled so that sniffing could be done is delivered on the first emission of #SoupMessage::got-chunk. the content type that we got from sniffing a #GHashTable with the parameters Emitted when all HTTP processing is finished for a message. (After #SoupMessage::got_body for client-side messages, or after #SoupMessage::wrote_body for server-side messages.) 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.) See also soup_message_add_header_handler() and soup_message_add_status_code_handler(), which can be used to connect to a subset of emissions of this signal. 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. If you cancel or requeue @msg while processing this signal, then the current HTTP I/O will be stopped after this signal emission finished, and @msg's connection will be closed. the just-read chunk 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.) See also soup_message_add_header_handler() and soup_message_add_status_code_handler(), which can be used to connect to a subset of emissions of this signal. If you cancel or requeue @msg while processing this signal, then the current HTTP I/O will be stopped after this signal emission finished, and @msg's connection will be closed. (If you need to requeue a message--eg, after handling authentication or redirection--it is usually better to requeue it from a #SoupMessage::got_body handler rather than a #SoupMessage::got_headers handler, so that the existing HTTP connection can be reused.) 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. If you cancel or requeue @msg while processing this signal, then the current HTTP I/O will be stopped after this signal emission finished, and @msg's connection will be closed. Emitted to indicate that some network-related event related to @msg has occurred. This essentially proxies the #GSocketClient::event signal, but only for events that occur while @msg "owns" the connection; if @msg is sent on an existing persistent connection, then this signal will not be emitted. (If you want to force the message to be sent on a new connection, set the %SOUP_MESSAGE_NEW_CONNECTION flag on it.) See #GSocketClient::event for more information on what the different values of @event correspond to, and what @connection will be in each case. the network event the current state of the network connection 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). Emitted just before a message is sent. 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.) Emitted immediately after writing a portion of the message body to the network. Unlike #SoupMessage::wrote_chunk, this is emitted after every successful write() call, not only after finishing a complete "chunk". the data written Emitted immediately after writing a body chunk for a message. Note that this signal is not parallel to #SoupMessage::got_chunk; it is emitted only when a complete chunk (added with soup_message_body_append() or soup_message_body_append_buffer()) has been written. To get more useful continuous progress information, use #SoupMessage::wrote_body_data. 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.) Emitted immediately after writing a 1xx (Informational) response for a (server-side) message. A #SoupMessage request or response body. Note that while @length always reflects the full length of the message body, @data is 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 @data is filled in, it is always terminated with a '\0' byte (which is not reflected in @length). the data length of @data Creates a new #SoupMessageBody. #SoupMessage uses this internally; you will not normally need to call it yourself. a new #SoupMessageBody. Appends @length bytes from @data to @body according to @use. a #SoupMessageBody how to use @data data to append length of @data Appends the data from @buffer to @body. (#SoupMessageBody uses #SoupBuffers internally, so this is normally a constant-time operation that doesn't actually require copying the data in @buffer.) a #SoupMessageBody a #SoupBuffer 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. a #SoupMessageBody data to append length of @data Tags @body as being complete; Call this when using chunked encoding after you have appended the last chunk. a #SoupMessageBody Fills in @body's data field with a buffer containing all of the data in @body (plus an additional '\0' byte not counted by @body's length field). a #SoupBuffer containing the same data as @body. (You must free this buffer if you do not want it.) a #SoupMessageBody Frees @body. You will not normally need to use this, as #SoupMessage frees its associated message bodies automatically. a #SoupMessageBody Gets the accumulate flag on @body; see soup_message_body_set_accumulate() for details. the accumulate flag for @body. a #SoupMessageBody 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). a #SoupBuffer, or %NULL. a #SoupMessageBody 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. a #SoupMessageBody a #SoupBuffer received from the network 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. a #SoupMessageBody whether or not to accumulate body chunks in @body Deletes all of the data in @body. a #SoupMessageBody 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. a #SoupMessageBody a #SoupBuffer returned from soup_message_body_get_chunk() Various flags that can be set on a #SoupMessage to alter its behavior. The session should not follow redirect (3xx) responses received by this message. The caller will rebuild the request body if the message is restarted; see soup_message_body_set_accumulate() for more details. Deprecated: equivalent to calling soup_message_body_set_accumulate() on the incoming message body (ie, #SoupMessage:response_body for a client-side request), passing %FALSE. Set by #SoupContentDecoder to indicate that it has removed the Content-Encoding on a message (and so headers such as Content-Length may no longer accurately describe the body). if set after an https response has been received, indicates that the server's SSL certificate is trusted according to the session's CA. Requests that the message should be sent on a newly-created connection, not reusing an existing persistent connection. Note that messages with non-idempotent #SoupMessage:method<!-- -->s behave this way by default, unless #SOUP_MESSAGE_IDEMPOTENT is set. The message is considered idempotent, regardless its #SoupMessage:method, and allows reuse of existing idle connections, instead of always requiring a new one, unless #SOUP_MESSAGE_NEW_CONNECTION is set. Request that a new connection is created for the message if there aren't idle connections available and it's not possible to create new connections due to any of the connection limits has been reached. If a dedicated connection is eventually created for this message, it will be dropped when the message finishes. Since 2.50 The #SoupAuthManager should not use the credentials cache for this message, neither to use cached credentials to automatically authenticate this message nor to cache the credentials after the message is successfully authenticated. This applies to both server and proxy authentication. Note that #SoupSession::authenticate signal will be emitted, if you want to disable authentication for a message use soup_message_disable_feature() passing #SOUP_TYPE_AUTH_MANAGER instead. Since 2.58 The HTTP message headers associated with a request or response. Creates a #SoupMessageHeaders. (#SoupMessage does this automatically for its own headers. You would only need to use this method if you are manually parsing or generating message headers.) a new #SoupMessageHeaders the type of headers Appends a new header with name @name and value @value to @hdrs. (If there is an existing header with name @name, then this creates a second one, which is only allowed for list-valued headers; see also soup_message_headers_replace().) The caller is expected to make sure that @name and @value are syntactically correct. a #SoupMessageHeaders the header name to add the new value of @name Removes all the headers listed in the Connection header. a #SoupMessageHeaders Clears @hdrs. a #SoupMessageHeaders Calls @func once for each header value in @hdrs. Beware that unlike soup_message_headers_get(), this processes the headers in exactly the way they were added, rather than concatenating multiple same-named headers into a single value. (This is intentional; it ensures that if you call soup_message_headers_append() multiple times with the same name, then the I/O code will output multiple copies of the header when sending the message to the remote implementation, which may be required for interoperability in some cases.) You may not modify the headers from @func. a #SoupMessageHeaders callback function to run for each header data to pass to @func Frees @hdrs. a #SoupMessageHeaders Frees the array of ranges returned from soup_message_headers_get_ranges(). a #SoupMessageHeaders an array of #SoupRange Gets the value of header @name in @hdrs. This method was supposed to work correctly for both single-valued and list-valued headers, but because some HTTP clients/servers mistakenly send multiple copies of headers that are supposed to be single-valued, it sometimes returns incorrect results. To fix this, the methods soup_message_headers_get_one() and soup_message_headers_get_list() were introduced, so callers can explicitly state which behavior they are expecting. Use soup_message_headers_get_one() or soup_message_headers_get_list() instead. as with soup_message_headers_get_list(). a #SoupMessageHeaders header name Looks up the "Content-Disposition" header in @hdrs, parses it, and returns its value in *@disposition and *@params. @params can be %NULL if you are only interested in the disposition-type. In HTTP, the most common use of this header is to set a disposition-type of "attachment", to suggest to the browser that a response should be saved to disk rather than displayed in the browser. If @params contains a "filename" parameter, this is a suggestion of a filename to use. (If the parameter value in the header contains an absolute or relative path, libsoup will truncate it down to just the final path component, so you do not need to test this yourself.) Content-Disposition is also used in "multipart/form-data", however this is handled automatically by #SoupMultipart and the associated form methods. %TRUE if @hdrs contains a "Content-Disposition" header, %FALSE if not (in which case *@disposition and *@params will be unchanged). a #SoupMessageHeaders return location for the disposition-type, or %NULL return location for the Content-Disposition parameters, or %NULL Gets the message body length that @hdrs declare. This will only be non-0 if soup_message_headers_get_encoding() returns %SOUP_ENCODING_CONTENT_LENGTH. the message body length declared by @hdrs. a #SoupMessageHeaders Parses @hdrs's Content-Range header and returns it in @start, @end, and @total_length. If the total length field in the header was specified as "*", then @total_length will be set to -1. %TRUE if @hdrs contained a "Content-Range" header containing a byte range which could be parsed, %FALSE otherwise. a #SoupMessageHeaders return value for the start of the range return value for the end of the range return value for the total length of the resource, or %NULL if you don't care. Looks up the "Content-Type" header in @hdrs, parses it, and returns its value in *@content_type and *@params. @params can be %NULL if you are only interested in the content type itself. a string with the value of the "Content-Type" header or %NULL if @hdrs does not contain that header or it cannot be parsed (in which case *@params will be unchanged). a #SoupMessageHeaders return location for the Content-Type parameters (eg, "charset"), or %NULL Gets the message body encoding that @hdrs declare. This may not always correspond to the encoding used on the wire; eg, a HEAD response may declare a Content-Length or Transfer-Encoding, but it will never actually include a body. the encoding declared by @hdrs. a #SoupMessageHeaders Gets the expectations declared by @hdrs's "Expect" header. Currently this will either be %SOUP_EXPECTATION_CONTINUE or %SOUP_EXPECTATION_UNRECOGNIZED. the contents of @hdrs's "Expect" header a #SoupMessageHeaders Gets the type of headers. the header's type. a #SoupMessageHeaders Gets the value of header @name in @hdrs. Use this for headers whose values are comma-delimited lists, and which are therefore allowed to appear multiple times in the headers. For non-list-valued headers, use soup_message_headers_get_one(). If @name appears multiple times in @hdrs, soup_message_headers_get_list() will concatenate all of the values together, separated by commas. This is sometimes awkward to parse (eg, WWW-Authenticate, Set-Cookie), but you have to be able to deal with it anyway, because the HTTP spec explicitly states that this transformation is allowed, and so an upstream proxy could do the same thing. the header's value or %NULL if not found. a #SoupMessageHeaders header name Gets the value of header @name in @hdrs. Use this for headers whose values are <emphasis>not</emphasis> comma-delimited lists, and which therefore can only appear at most once in the headers. For list-valued headers, use soup_message_headers_get_list(). If @hdrs does erroneously contain multiple copies of the header, it is not defined which one will be returned. (Ideally, it will return whichever one makes libsoup most compatible with other HTTP implementations.) the header's value or %NULL if not found. a #SoupMessageHeaders header name Parses @hdrs's Range header and returns an array of the requested byte ranges. The returned array must be freed with soup_message_headers_free_ranges(). If @total_length is non-0, its value will be used to adjust the returned ranges to have explicit start and end values, and the returned ranges will be sorted and non-overlapping. If @total_length is 0, then some ranges may have an end value of -1, as described under #SoupRange, and some of the ranges may be redundant. Beware that even if given a @total_length, this function does not check that the ranges are satisfiable. <note><para> #SoupServer has built-in handling for range requests. If your server handler returns a %SOUP_STATUS_OK response containing the complete response body (rather than pausing the message and returning some of the response body later), and there is a Range header in the request, then libsoup will automatically convert the response to a %SOUP_STATUS_PARTIAL_CONTENT response containing only the range(s) requested by the client. The only time you need to process the Range header yourself is if either you need to stream the response body rather than returning it all at once, or you do not already have the complete response body available, and only want to generate the parts that were actually requested by the client. </para></note> %TRUE if @hdrs contained a syntactically-valid "Range" header, %FALSE otherwise (in which case @range and @length will not be set). a #SoupMessageHeaders the total_length of the response body return location for an array of #SoupRange the length of the returned array Checks whether the list-valued header @name is present in @hdrs, and contains a case-insensitive match for @token. (If @name is present in @hdrs, then this is equivalent to calling soup_header_contains() on its value.) %TRUE if the header is present and contains @token, %FALSE otherwise. a #SoupMessageHeaders header name token to look for Checks whether the header @name is present in @hdrs and is (case-insensitively) equal to @value. %TRUE if the header is present and its value is @value, %FALSE otherwise. a #SoupMessageHeaders header name expected value Removes @name from @hdrs. If there are multiple values for @name, they are all removed. a #SoupMessageHeaders the header name to remove Replaces the value of the header @name in @hdrs with @value. (See also soup_message_headers_append().) The caller is expected to make sure that @name and @value are syntactically correct. a #SoupMessageHeaders the header name to replace the new value of @name Sets the "Content-Disposition" header in @hdrs to @disposition, optionally with additional parameters specified in @params. See soup_message_headers_get_content_disposition() for a discussion of how Content-Disposition is used in HTTP. a #SoupMessageHeaders the disposition-type additional parameters, or %NULL Sets the message body length that @hdrs will declare, and sets @hdrs's encoding to %SOUP_ENCODING_CONTENT_LENGTH. You do not normally need to call this; if @hdrs is set to use Content-Length encoding, libsoup will automatically set its Content-Length header for you immediately before sending the headers. One situation in which this method is useful is when generating the response to a HEAD request; Calling soup_message_headers_set_content_length() allows you to put the correct content length into the response without needing to waste memory by filling in a response body which won't actually be sent. a #SoupMessageHeaders the message body length Sets @hdrs's Content-Range header according to the given values. (Note that @total_length is the total length of the entire resource that this is a range of, not simply @end - @start + 1.) <note><para> #SoupServer has built-in handling for range requests, and you do not normally need to call this function youself. See soup_message_headers_get_ranges() for more details. </para></note> a #SoupMessageHeaders the start of the range the end of the range the total length of the resource, or -1 if unknown Sets the "Content-Type" header in @hdrs to @content_type, optionally with additional parameters specified in @params. a #SoupMessageHeaders the MIME type additional parameters, or %NULL Sets the message body encoding that @hdrs will declare. In particular, you should use this if you are going to send a request or response in chunked encoding. a #SoupMessageHeaders a #SoupEncoding Sets @hdrs's "Expect" header according to @expectations. Currently %SOUP_EXPECTATION_CONTINUE is the only known expectation value. You should set this value on a request if you are sending a large message body (eg, via POST or PUT), and want to give the server a chance to reject the request after seeing just the headers (eg, because it will require authentication before allowing you to post, or because you're POSTing to a URL that doesn't exist). This saves you from having to transmit the large request body when the server is just going to ignore it anyway. a #SoupMessageHeaders the expectations to set Sets @hdrs's Range header to request the indicated range. @start and @end are interpreted as in a #SoupRange. If you need to request multiple ranges, use soup_message_headers_set_ranges(). a #SoupMessageHeaders the start of the range to request the end of the range to request Sets @hdrs's Range header to request the indicated ranges. (If you only want to request a single range, you can use soup_message_headers_set_range().) a #SoupMessageHeaders an array of #SoupRange the length of @range The callback passed to soup_message_headers_foreach(). the header name the header value the data passed to soup_message_headers_foreach() An opaque type used to iterate over a %SoupMessageHeaders structure. After intializing the iterator with soup_message_headers_iter_init(), call soup_message_headers_iter_next() to fetch data from it. You may not modify the headers while iterating over them. Yields the next name/value pair in the %SoupMessageHeaders being iterated by @iter. If @iter has already yielded the last header, then soup_message_headers_iter_next() will return %FALSE and @name and @value will be unchanged. %TRUE if another name and value were returned, %FALSE if the end of the headers has been reached. a %SoupMessageHeadersIter pointer to a variable to return the header name in pointer to a variable to return the header value in Initializes @iter for iterating @hdrs. a pointer to a %SoupMessageHeadersIter structure a %SoupMessageHeaders Value passed to soup_message_headers_new() to set certain default behaviors. request headers response headers multipart body part headers Priorities that can be set on a #SoupMessage to instruct the message queue to process it before any other message with lower priority. The lowest priority, the messages with this priority will be the last ones to be attended. Use this for low priority messages, a #SoupMessage with the default priority will be processed first. The default priotity, this is the priority assigned to the #SoupMessage by default. High priority, a #SoupMessage with this priority will be processed before the ones with the default priority. The highest priority, use this for very urgent #SoupMessage as they will be the first ones to be attended. Represents a multipart HTTP message body, parsed according to the syntax of RFC 2046. Of particular interest to HTTP are <literal>multipart/byte-ranges</literal> and <literal>multipart/form-data</literal>. Although the headers of a #SoupMultipart body part will contain the full headers from that body part, libsoup does not interpret them according to MIME rules. For example, each body part is assumed to have "binary" Content-Transfer-Encoding, even if its headers explicitly state otherwise. In other words, don't try to use #SoupMultipart for handling real MIME multiparts. Creates a new empty #SoupMultipart with a randomly-generated boundary string. Note that @mime_type must be the full MIME type, including "multipart/". a new empty #SoupMultipart of the given @mime_type the MIME type of the multipart to create. Parses @headers and @body to form a new #SoupMultipart a new #SoupMultipart (or %NULL if the message couldn't be parsed or wasn't multipart). the headers of the HTTP message to parse the body of the HTTP message to parse Adds a new MIME part containing @body to @multipart, using "Content-Disposition: form-data", as per the HTML forms specification. See soup_form_request_new_from_multipart() for more details. a multipart (presumably of type "multipart/form-data") the name of the control associated with this file the name of the file, or %NULL if not known the MIME type of the file, or %NULL if not known the file data Adds a new MIME part containing @data to @multipart, using "Content-Disposition: form-data", as per the HTML forms specification. See soup_form_request_new_from_multipart() for more details. a multipart (presumably of type "multipart/form-data") the name of the control associated with @data the body data Adds a new MIME part to @multipart with the given headers and body. (The multipart will make its own copies of @headers and @body, so you should free your copies if you are not using them for anything else.) a #SoupMultipart the MIME part headers the MIME part body Frees @multipart a #SoupMultipart Gets the number of body parts in @multipart the number of body parts in @multipart a #SoupMultipart Gets the indicated body part from @multipart. %TRUE on success, %FALSE if @part is out of range (in which case @headers and @body won't be set) a #SoupMultipart the part number to get (counting from 0) return location for the MIME part headers return location for the MIME part body Serializes @multipart to @dest_headers and @dest_body. a #SoupMultipart the headers of the HTTP message to serialize @multipart to the body of the HTTP message to serialize @multipart to Creates a new #SoupMultipartInputStream that wraps the #GInputStream obtained by sending the #SoupRequest. Reads should not be done directly through this object, use the input streams returned by soup_multipart_input_stream_next_part() or its async counterpart instead. a new #SoupMultipartInputStream the #SoupMessage the response is related to. the #GInputStream returned by sending the request. Obtains the headers for the part currently being processed. Note that the #SoupMessageHeaders that are returned are owned by the #SoupMultipartInputStream and will be replaced when a call is made to soup_multipart_input_stream_next_part() or its async counterpart, so if keeping the headers is required, a copy must be made. Note that if a part had no headers at all an empty #SoupMessageHeaders will be returned. a #SoupMessageHeaders containing the headers for the part currently being processed or %NULL if the headers failed to parse. a #SoupMultipartInputStream. Obtains an input stream for the next part. When dealing with a multipart response the input stream needs to be wrapped in a #SoupMultipartInputStream and this function or its async counterpart need to be called to obtain the first part for reading. After calling this function, soup_multipart_input_stream_get_headers() can be used to obtain the headers for the first part. A read of 0 bytes indicates the end of the part; a new call to this function should be done at that point, to obtain the next part. a new #GInputStream, or %NULL if there are no more parts the #SoupMultipartInputStream a #GCancellable Obtains a #GInputStream for the next request. See soup_multipart_input_stream_next_part() for details on the workflow. the #SoupMultipartInputStream. the I/O priority for the request. a #GCancellable. callback to call when request is satisfied. data for @callback Finishes an asynchronous request for the next part. a newly created #GInputStream for reading the next part or %NULL if there are no more parts. a #SoupMultipartInputStream. a #GAsyncResult. Use SoupProxyURIResolver.get_proxy_uri_async instead Use SoupProxyURIResolver.get_proxy_uri_sync() instead Use SoupProxyURIResolver.get_proxy_uri_async instead Use SoupProxyURIResolver.get_proxy_uri_sync() instead Use SoupProxyURIResolver instead Asynchronously determines a proxy URI to use for @msg and calls @callback. #SoupProxyURIResolver is deprecated in favor of #GProxyResolver the #SoupProxyURIResolver the #SoupURI you want a proxy for the #GMainContext to invoke @callback in a #GCancellable, or %NULL callback to invoke with the proxy address data for @callback Synchronously determines a proxy URI to use for @uri. If @uri should be sent via proxy, *@proxy_uri will be set to the URI of the proxy, else it will be set to %NULL. #SoupProxyURIResolver is deprecated in favor of #GProxyResolver %SOUP_STATUS_OK if successful, or a transport-level error. the #SoupProxyURIResolver the #SoupURI you want a proxy for a #GCancellable, or %NULL on return, will contain the proxy URI Asynchronously determines a proxy URI to use for @msg and calls @callback. #SoupProxyURIResolver is deprecated in favor of #GProxyResolver the #SoupProxyURIResolver the #SoupURI you want a proxy for the #GMainContext to invoke @callback in a #GCancellable, or %NULL callback to invoke with the proxy address data for @callback Synchronously determines a proxy URI to use for @uri. If @uri should be sent via proxy, *@proxy_uri will be set to the URI of the proxy, else it will be set to %NULL. #SoupProxyURIResolver is deprecated in favor of #GProxyResolver %SOUP_STATUS_OK if successful, or a transport-level error. the #SoupProxyURIResolver the #SoupURI you want a proxy for a #GCancellable, or %NULL on return, will contain the proxy URI Callback for soup_proxy_uri_resolver_get_proxy_uri_async() the #SoupProxyURIResolver a #SoupStatus the resolved proxy URI, or %NULL data passed to soup_proxy_uri_resolver_get_proxy_uri_async() the #SoupProxyURIResolver the #SoupURI you want a proxy for the #GMainContext to invoke @callback in a #GCancellable, or %NULL callback to invoke with the proxy address data for @callback %SOUP_STATUS_OK if successful, or a transport-level error. the #SoupProxyURIResolver the #SoupURI you want a proxy for a #GCancellable, or %NULL on return, will contain the proxy URI Alias for the #SoupRequest:session property, qv. Alias for the #SoupRequest:uri property, qv. Represents a byte range as used in the Range header. If @end is non-negative, then @start and @end represent the bounds of of the range, counting from 0. (Eg, the first 500 bytes would be represented as @start = 0 and @end = 499.) If @end is -1 and @start is non-negative, then this represents a range starting at @start and ending with the last byte of the requested resource body. (Eg, all but the first 500 bytes would be @start = 500, and @end = -1.) If @end is -1 and @start is negative, then it represents a "suffix range", referring to the last -@start bytes of the resource body. (Eg, the last 500 bytes would be @start = -500 and @end = -1.) the start of the range the end of the range A request to retrieve a particular URI. Gets the length of the data represented by @request. For most request types, this will not be known until after you call soup_request_send() or soup_request_send_finish(). the length of the data represented by @request, or -1 if not known. a #SoupRequest Gets the type of the data represented by @request. For most request types, this will not be known until after you call soup_request_send() or soup_request_send_finish(). As in the HTTP Content-Type header, this may include parameters after the MIME type. the type of the data represented by @request, or %NULL if not known. a #SoupRequest Synchronously requests the URI pointed to by @request, and returns a #GInputStream that can be used to read its contents. Note that you cannot use this method with #SoupRequests attached to a #SoupSessionAsync. a #GInputStream that can be used to read from the URI pointed to by @request. a #SoupRequest a #GCancellable or %NULL Begins an asynchronously request for the URI pointed to by @request. Note that you cannot use this method with #SoupRequests attached to a #SoupSessionSync. a #SoupRequest a #GCancellable or %NULL a #GAsyncReadyCallback user data passed to @callback Gets the result of a soup_request_send_async(). a #GInputStream that can be used to read from the URI pointed to by @request. a #SoupRequest the #GAsyncResult Gets the length of the data represented by @request. For most request types, this will not be known until after you call soup_request_send() or soup_request_send_finish(). the length of the data represented by @request, or -1 if not known. a #SoupRequest Gets the type of the data represented by @request. For most request types, this will not be known until after you call soup_request_send() or soup_request_send_finish(). As in the HTTP Content-Type header, this may include parameters after the MIME type. the type of the data represented by @request, or %NULL if not known. a #SoupRequest Gets @request's #SoupSession @request's #SoupSession a #SoupRequest Gets @request's URI @request's URI a #SoupRequest Synchronously requests the URI pointed to by @request, and returns a #GInputStream that can be used to read its contents. Note that you cannot use this method with #SoupRequests attached to a #SoupSessionAsync. a #GInputStream that can be used to read from the URI pointed to by @request. a #SoupRequest a #GCancellable or %NULL Begins an asynchronously request for the URI pointed to by @request. Note that you cannot use this method with #SoupRequests attached to a #SoupSessionSync. a #SoupRequest a #GCancellable or %NULL a #GAsyncReadyCallback user data passed to @callback Gets the result of a soup_request_send_async(). a #GInputStream that can be used to read from the URI pointed to by @request. a #SoupRequest the #GAsyncResult The request's #SoupSession. The request URI. a #GInputStream that can be used to read from the URI pointed to by @request. a #SoupRequest a #GCancellable or %NULL a #SoupRequest a #GCancellable or %NULL a #GAsyncReadyCallback user data passed to @callback a #GInputStream that can be used to read from the URI pointed to by @request. a #SoupRequest the #GAsyncResult the length of the data represented by @request, or -1 if not known. a #SoupRequest the type of the data represented by @request, or %NULL if not known. a #SoupRequest A #SoupRequest error. the URI could not be parsed the URI scheme is not supported by this #SoupSession the server's response could not be parsed the server's response was in an unsupported format Gets a #GFile corresponding to @file's URI a #GFile corresponding to @file a #SoupRequestFile Gets a new reference to the #SoupMessage associated to this SoupRequest a new reference to the #SoupMessage a #SoupRequestHTTP object Alias for the #SoupServer:add-websocket-extension property, qv. Alias for the deprecated #SoupServer:async-context property, qv. The new API uses the thread-default #GMainContext rather than having an explicitly-specified one. Alias for the #SoupServer:https-aliases property, qv. Alias for the #SoupServer:http-aliases property, qv. Alias for the #SoupServer:interface property, qv. #SoupServers can listen on multiple interfaces at once now. Use soup_server_listen(), etc, to listen on an interface, and soup_server_get_uris() to see what addresses are being listened on. Alias for the deprecated #SoupServer:port property, qv. #SoupServers can listen on multiple interfaces at once now. Use soup_server_listen(), etc, to listen on a port, and soup_server_get_uris() to see what ports are being listened on. Alias for the #SoupServer:raw-paths property. (If %TRUE, percent-encoding in the Request-URI path will not be automatically decoded.) Alias for the #SoupServer:remove-websocket-extension property, qv. Alias for the #SoupServer:server-header property, qv. Alias for the #SoupServer:ssl-cert-file property, qv. use #SoupServer:tls-certificate or soup_server_set_ssl_certificate(). Alias for the #SoupServer:ssl-key-file property, qv. use #SoupServer:tls-certificate or soup_server_set_ssl_certificate(). Alias for the #SoupServer:tls-certificate property, qv. Alias for the #SoupSession:accept-language property, qv. Alias for the #SoupSession:accept-language-auto property, qv. Alias for the #SoupSession:add-feature property, qv. Alias for the #SoupSession:add-feature-by-type property, qv. Alias for the #SoupSession:async-context property, qv. Alias for the #SoupSession:https-aliases property, qv. Alias for the #SoupSession:http-aliases property, qv. Alias for the #SoupSession:idle-timeout property, qv. Alias for the #SoupSession:local-address property, qv. Alias for the #SoupSession:max-conns property, qv. Alias for the #SoupSession:max-conns-per-host property, qv. Alias for the #SoupSession:proxy-resolver property, qv. Alias for the #SoupSession:proxy-uri property, qv. Alias for the #SoupSession:remove-feature-by-type property, qv. Alias for the #SoupSession:ssl-ca-file property, qv. Alias for the #SoupSession:ssl-strict property, qv. Alias for the #SoupSession:ssl-use-system-ca-file property, qv. Alias for the #SoupSession:timeout property, qv. Alias for the #SoupSession:tls-database property, qv. Alias for the #SoupSession:tls-interaction property, qv. Alias for the #SoupSession:user-agent property, qv. Alias for the #SoupSession:use-ntlm property, qv. Alias for the #SoupSession:use-thread-context property, qv. Alias for the #SoupSocket:async-context property. (The socket's #GMainContext.) Alias for the #SoupSocket:non-blocking property. (Whether or not the socket uses non-blocking I/O.) Alias for the #SoupSocket:is-server property, qv. Alias for the #SoupSocket:local-address property. (Address of local end of socket.) Alias for the #SoupSocket:remote-address property. (Address of remote end of socket.) Alias for the #SoupSocket:ssl-creds property. (SSL credential information.) Alias for the #SoupSocket:ssl-fallback property. Alias for the #SoupSocket:ssl-strict property. Alias for the #SoupSocket:timeout property. (The timeout in seconds for blocking socket I/O operations.) Alias for the #SoupSocket:tls-certificate property. Note that this property's value is only useful if the socket is for a TLS connection, and only reliable after some data has been transferred to or from it. Alias for the #SoupSocket:tls-errors property. Note that this property's value is only useful if the socket is for a TLS connection, and only reliable after some data has been transferred to or from it. Alias for the #SoupSocket:trusted-certificate property. Alias for the #SoupSocket:use-thread-context property. (Use g_main_context_get_thread_default()) Tests if @status is a Client Error (4xx) response. an HTTP status code Tests if @status is an Informational (1xx) response. an HTTP status code Tests if @status is a Redirection (3xx) response. an HTTP status code Tests if @status is a Server Error (5xx) response. an HTTP status code Tests if @status is a Successful (2xx) response. an HTTP status code Tests if @status is a libsoup transport error. a status code The cookie is exposed with both cross-site and same-site requests The cookie is withheld on cross-site requests but exposed on cross-site navigations The cookie is only exposed for same-site requests Creates a new #SoupServer. This is exactly equivalent to calling g_object_new() and specifying %SOUP_TYPE_SERVER as the type. a new #SoupServer. If you are using certain legacy properties, this may also return %NULL if an error occurs. name of first property to set value of @optname1, followed by additional property/value pairs Add a new client stream to the @server. %TRUE on success, %FALSE if the stream could not be accepted or any other error occurred (in which case @error will be set). a #SoupServer a #GIOStream the local #GSocketAddress associated with the @stream the remote #GSocketAddress associated with the @stream Adds an authentication domain to @server. Each auth domain will have the chance to require authentication for each request that comes in; normally auth domains will require authentication for requests on certain paths that they have been set up to watch, or that meet other criteria set by the caller. If an auth domain determines that a request requires authentication (and the request doesn't contain authentication), @server will automatically reject the request with an appropriate status (401 Unauthorized or 407 Proxy Authentication Required). If the request used the "100-continue" Expectation, @server will reject it before the request body is sent. a #SoupServer a #SoupAuthDomain Adds an "early" handler to @server for requests under @path. Note that "normal" and "early" handlers are matched up together, so if you add a normal handler for "/foo" and an early handler for "/foo/bar", then a request to "/foo/bar" (or any path below it) will run only the early handler. (But if you add both handlers at the same path, then both will get run.) For requests under @path (that have not already been assigned a status code by a #SoupAuthDomain or a signal handler), @callback will be invoked after receiving the request headers, but before receiving the request body; the message's #SoupMessage:method and #SoupMessage:request-headers fields will be filled in. Early handlers are generally used for processing requests with request bodies in a streaming fashion. If you determine that the request will contain a message body, normally you would call soup_message_body_set_accumulate() on the message's #SoupMessage:request-body to turn off request-body accumulation, and connect to the message's #SoupMessage::got-chunk signal to process each chunk as it comes in. To complete the message processing after the full message body has been read, you can either also connect to #SoupMessage::got-body, or else you can register a non-early handler for @path as well. As long as you have not set the #SoupMessage:status-code by the time #SoupMessage::got-body is emitted, the non-early handler will be run as well. a #SoupServer the toplevel path for the handler callback to invoke for requests under @path data for @callback destroy notifier to free @user_data Adds a handler to @server for requests under @path. If @path is %NULL or "/", then this will be the default handler for all requests that don't have a more specific handler. (Note though that if you want to handle requests to the special "*" URI, you must explicitly register a handler for "*"; the default handler will not be used for that case.) For requests under @path (that have not already been assigned a status code by a #SoupAuthDomain, an early #SoupServerHandler, or a signal handler), @callback will be invoked after receiving the request body; the message's #SoupMessage:method, #SoupMessage:request-headers, and #SoupMessage:request-body fields will be filled in. After determining what to do with the request, the callback must at a minimum call soup_message_set_status() (or soup_message_set_status_full()) on the message to set the response status code. Additionally, it may set response headers and/or fill in the response body. If the callback cannot fully fill in the response before returning (eg, if it needs to wait for information from a database, or another network server), it should call soup_server_pause_message() to tell @server to not send the response right away. When the response is ready, call soup_server_unpause_message() to cause it to be sent. To send the response body a bit at a time using "chunked" encoding, first call soup_message_headers_set_encoding() to set %SOUP_ENCODING_CHUNKED on the #SoupMessage:response-headers. Then call soup_message_body_append() (or soup_message_body_append_buffer()) to append each chunk as it becomes ready, and soup_server_unpause_message() to make sure it's running. (The server will automatically pause the message if it is using chunked encoding but no more chunks are available.) When you are done, call soup_message_body_complete() to indicate that no more chunks are coming. a #SoupServer the toplevel path for the handler callback to invoke for requests under @path data for @callback destroy notifier to free @user_data Add support for a WebSocket extension of the given @extension_type. When a WebSocket client requests an extension of @extension_type, a new #SoupWebsocketExtension of type @extension_type will be created to handle the request. You can also add support for a WebSocket extension to the server at construct time by using the %SOUP_SERVER_ADD_WEBSOCKET_EXTENSION property. Note that #SoupWebsocketExtensionDeflate is supported by default, use soup_server_remove_websocket_extension() if you want to disable it. a #SoupServer a #GType Adds a WebSocket handler to @server for requests under @path. (If @path is %NULL or "/", then this will be the default handler for all requests that don't have a more specific handler.) When a path has a WebSocket handler registered, @server will check incoming requests for WebSocket handshakes after all other handlers have run (unless some earlier handler has already set a status code on the message), and update the request's status, response headers, and response body accordingly. If @origin is non-%NULL, then only requests containing a matching "Origin" header will be accepted. If @protocols is non-%NULL, then only requests containing a compatible "Sec-WebSocket-Protocols" header will be accepted. More complicated requirements can be handled by adding a normal handler to @path, and having it perform whatever checks are needed (possibly calling soup_server_check_websocket_handshake() one or more times), and setting a failure status code if the handshake should be rejected. a #SoupServer the toplevel path for the handler the origin of the connection the protocols supported by this handler callback to invoke for successful WebSocket requests under @path data for @callback destroy notifier to free @user_data Closes and frees @server's listening sockets. If you are using the old #SoupServer APIs, this also includes the effect of soup_server_quit(). Note that if there are currently requests in progress on @server, that they will continue to be processed if @server's #GMainContext is still running. You can call soup_server_listen(), etc, after calling this function if you want to start listening again. a #SoupServer Gets @server's async_context, if you are using the old API. (With the new API, the server runs in the thread's thread-default #GMainContext, regardless of what this method returns.) This does not add a ref to the context, so you will need to ref it yourself if you want it to outlive its server. If you are using soup_server_listen(), etc, then the server listens on the thread-default #GMainContext, and this property is ignored. @server's #GMainContext, which may be %NULL a #SoupServer Gets @server's listening socket, if you are using the old API. You should treat this socket as read-only; writing to it or modifiying it may cause @server to malfunction. If you are using soup_server_listen(), etc, then use soup_server_get_listeners() to get a list of all listening sockets, but note that that function returns #GSockets, not #SoupSockets. the listening socket. a #SoupServer Gets @server's list of listening sockets. You should treat these sockets as read-only; writing to or modifiying any of these sockets may cause @server to malfunction. (Beware that in contrast to the old soup_server_get_listener(), this function returns #GSockets, not #SoupSockets.) a list of listening sockets. a #SoupServer Gets the TCP port that @server is listening on, if you are using the old API. If you are using soup_server_listen(), etc, then use soup_server_get_uris() to get a list of all listening addresses. the port @server is listening on. a #SoupServer Gets a list of URIs corresponding to the interfaces @server is listening on. These will contain IP addresses, not hostnames, and will also indicate whether the given listener is http or https. Note that if you used soup_server_listen_all(), the returned URIs will use the addresses <literal>0.0.0.0</literal> and <literal>::</literal>, rather than actually returning separate URIs for each interface on the system. a list of #SoupURIs, which you must free when you are done with it. a #SoupServer Checks whether @server is capable of https. In order for a server to run https, you must call soup_server_set_ssl_cert_file(), or set the #SoupServer:tls-certificate property, to provide it with a certificate to use. If you are using the deprecated single-listener APIs, then a return value of %TRUE indicates that the #SoupServer serves https exclusively. If you are using soup_server_listen(), etc, then a %TRUE return value merely indicates that the server is <emphasis>able</emphasis> to do https, regardless of whether it actually currently is or not. Use soup_server_get_uris() to see if it currently has any https listeners. %TRUE if @server is configured to serve https. a #SoupServer This attempts to set up @server to listen for connections on @address. If @options includes %SOUP_SERVER_LISTEN_HTTPS, and @server has been configured for TLS, then @server will listen for https connections on this port. Otherwise it will listen for plain http. You may call this method (along with the other "listen" methods) any number of times on a server, if you want to listen on multiple ports, or set up both http and https service. After calling this method, @server will begin accepting and processing connections as soon as the appropriate #GMainContext is run. Note that #SoupServer never makes use of dual IPv4/IPv6 sockets; if @address is an IPv6 address, it will only accept IPv6 connections. You must configure IPv4 listening separately. %TRUE on success, %FALSE if @address could not be bound or any other error occurred (in which case @error will be set). a #SoupServer the address of the interface to listen on listening options for this server This attempts to set up @server to listen for connections on all interfaces on the system. (That is, it listens on the addresses <literal>0.0.0.0</literal> and/or <literal>::</literal>, depending on whether @options includes %SOUP_SERVER_LISTEN_IPV4_ONLY, %SOUP_SERVER_LISTEN_IPV6_ONLY, or neither.) If @port is specified, @server will listen on that port. If it is 0, @server will find an unused port to listen on. (In that case, you can use soup_server_get_uris() to find out what port it ended up choosing.) See soup_server_listen() for more details. %TRUE on success, %FALSE if @port could not be bound or any other error occurred (in which case @error will be set). a #SoupServer the port to listen on, or 0 listening options for this server This attempts to set up @server to listen for connections on @fd. See soup_server_listen() for more details. Note that @server will close @fd when you free it or call soup_server_disconnect(). %TRUE on success, %FALSE if an error occurred (in which case @error will be set). a #SoupServer the file descriptor of a listening socket listening options for this server This attempts to set up @server to listen for connections on "localhost" (that is, <literal>127.0.0.1</literal> and/or <literal>::1</literal>, depending on whether @options includes %SOUP_SERVER_LISTEN_IPV4_ONLY, %SOUP_SERVER_LISTEN_IPV6_ONLY, or neither). If @port is specified, @server will listen on that port. If it is 0, @server will find an unused port to listen on. (In that case, you can use soup_server_get_uris() to find out what port it ended up choosing.) See soup_server_listen() for more details. %TRUE on success, %FALSE if @port could not be bound or any other error occurred (in which case @error will be set). a #SoupServer the port to listen on, or 0 listening options for this server This attempts to set up @server to listen for connections on @socket. See soup_server_listen() for more details. %TRUE on success, %FALSE if an error occurred (in which case @error will be set). a #SoupServer a listening #GSocket listening options for this server Pauses I/O on @msg. This can be used when you need to return from the server handler without having the full response ready yet. Use soup_server_unpause_message() to resume I/O. This must only be called on #SoupMessages which were created by the #SoupServer and are currently doing I/O, such as those passed into a #SoupServerCallback or emitted in a #SoupServer::request-read signal. a #SoupServer a #SoupMessage associated with @server. Stops processing for @server, if you are using the old API. Call this to clean up after soup_server_run_async(), or to terminate a call to soup_server_run(). Note that messages currently in progress will continue to be handled, if the main loop associated with the server is resumed or kept running. @server is still in a working state after this call; you can start and stop a server as many times as you want. When using soup_server_listen(), etc, the server will always listen for connections, and will process them whenever the thread-default #GMainContext is running. a #SoupServer Removes @auth_domain from @server. a #SoupServer a #SoupAuthDomain Removes all handlers (early and normal) registered at @path. a #SoupServer the toplevel path for the handler Removes support for WebSocket extension of type @extension_type (or any subclass of @extension_type) from @server. You can also remove extensions enabled by default from the server at construct time by using the %SOUP_SERVER_REMOVE_WEBSOCKET_EXTENSION property. a #SoupServer a #GType Starts @server, if you are using the old API, causing it to listen for and process incoming connections. Unlike soup_server_run_async(), this creates a #GMainLoop and runs it, and it will not return until someone calls soup_server_quit() to stop the server. When using soup_server_listen(), etc, the server will always listen for connections, and will process them whenever the thread-default #GMainContext is running. a #SoupServer Starts @server, if you are using the old API, causing it to listen for and process incoming connections. The server runs in @server's #GMainContext. It will not actually perform any processing unless the appropriate main loop is running. In the simple case where you did not set the server's %SOUP_SERVER_ASYNC_CONTEXT property, this means the server will run whenever the glib main loop is running. When using soup_server_listen(), etc, the server will always listen for connections, and will process them whenever the thread-default #GMainContext is running. a #SoupServer Sets @server up to do https, using the SSL/TLS certificate specified by @ssl_cert_file and @ssl_key_file (which may point to the same file). Alternatively, you can set the #SoupServer:tls-certificate property at construction time, if you already have a #GTlsCertificate. success or failure. a #SoupServer path to a file containing a PEM-encoded SSL/TLS certificate. path to a file containing a PEM-encoded private key. Resumes I/O on @msg. Use this to resume after calling soup_server_pause_message(), or after adding a new chunk to a chunked response. I/O won't actually resume until you return to the main loop. This must only be called on #SoupMessages which were created by the #SoupServer and are currently doing I/O, such as those passed into a #SoupServerCallback or emitted in a #SoupServer::request-read signal. a #SoupServer a #SoupMessage associated with @server. Add support for #SoupWebsocketExtension of the given type. (Shortcut for calling soup_server_add_websocket_extension().) The server's #GMainContext, if you are using the old API. Servers created using soup_server_listen() will listen on the #GMainContext that was the thread-default context at the time soup_server_listen() was called. The new API uses the thread-default #GMainContext rather than having an explicitly-specified one. A %NULL-terminated array of URI schemes that should be considered to be aliases for "http". Eg, if this included <literal>"dav"</literal>, than a URI of <literal>dav://example.com/path</literal> would be treated identically to <literal>http://example.com/path</literal>. In particular, this is needed in cases where a client sends requests with absolute URIs, where those URIs do not use "http:". The default value is an array containing the single element <literal>"*"</literal>, a special value which means that any scheme except "https" is considered to be an alias for "http". See also #SoupServer:https-aliases. A comma-delimited list of URI schemes that should be considered to be aliases for "https". See #SoupServer:http-aliases for more information. The default value is %NULL, meaning that no URI schemes are considered aliases for "https". The address of the network interface the server is listening on, if you are using the old #SoupServer API. (This will not be set if you use soup_server_listen(), etc.) #SoupServers can listen on multiple interfaces at once now. Use soup_server_listen(), etc, to listen on an interface, and soup_server_get_uris() to see what addresses are being listened on. The port the server is listening on, if you are using the old #SoupServer API. (This will not be set if you use soup_server_listen(), etc.) #SoupServers can listen on multiple interfaces at once now. Use soup_server_listen(), etc, to listen on a port, and soup_server_get_uris() to see what ports are being listened on. Remove support for #SoupWebsocketExtension of the given type. (Shortcut for calling soup_server_remove_websocket_extension().) If non-%NULL, the value to use for the "Server" header on #SoupMessage<!-- -->s processed by this server. The Server header is the server equivalent of the User-Agent header, and provides information about the server and its components. It contains a list of one or more product tokens, separated by whitespace, with the most significant product token coming first. The tokens must be brief, ASCII, and mostly alphanumeric (although "-", "_", and "." are also allowed), and may optionally include a "/" followed by a version string. You may also put comments, enclosed in parentheses, between or after the tokens. Some HTTP server implementations intentionally do not use version numbers in their Server header, so that installations running older versions of the server don't end up advertising their vulnerability to specific security holes. As with #SoupSession:user_agent, if you set a #SoupServer:server_header property that has trailing whitespace, #SoupServer will append its own product token (eg, "<literal>libsoup/2.3.2</literal>") to the end of the header for you. Path to a file containing a PEM-encoded certificate. If you set this property and #SoupServer:ssl-key-file at construct time, then soup_server_new() will try to read the files; if it cannot, it will return %NULL, with no explicit indication of what went wrong (and logging a warning with newer versions of glib, since returning %NULL from a constructor is illegal). use #SoupServer:tls-certificate or soup_server_set_ssl_certificate(). Path to a file containing a PEM-encoded private key. See #SoupServer:ssl-cert-file for more information about how this is used. use #SoupServer:tls-certificate or soup_server_set_ssl_certificate(). A #GTlsCertificate that has a #GTlsCertificate:private-key set. If this is set, then the server will be able to speak https in addition to (or instead of) plain http. Alternatively, you can call soup_server_set_ssl_cert_file() to have #SoupServer read in a a certificate from a file. Emitted when processing has failed for a message; this could mean either that it could not be read (if #SoupServer::request_read has not been emitted for it yet), or that the response could not be written back (if #SoupServer::request_read has been emitted but #SoupServer::request_finished has not been). @message is in an undefined state when this signal is emitted; the signal exists primarily to allow the server to free any state that it may have allocated in #SoupServer::request_started. the message the client context Emitted when the server has finished writing a response to a request. the message the client context Emitted when the server has successfully read a request. @message will have all of its request-side information filled in, and if the message was authenticated, @client will have information about that. This signal is emitted before any (non-early) handlers are called for the message, and if it sets the message's #status_code, then normal handler processing will be skipped. the message the client context Emitted when the server has started reading a new request. @message will be completely blank; not even the Request-Line will have been read yet. About the only thing you can usefully do with it is connect to its signals. If the request is read successfully, this will eventually be followed by a #SoupServer::request_read signal. If a response is then sent, the request processing will end with a #SoupServer::request_finished signal. If a network error occurs, the processing will instead end with #SoupServer::request_aborted. the new message the client context A callback used to handle requests to a #SoupServer. @path and @query contain the likewise-named components of the Request-URI, subject to certain assumptions. By default, #SoupServer decodes all percent-encoding in the URI path, such that "/foo%<!-- -->2Fbar" is treated the same as "/foo/bar". If your server is serving resources in some non-POSIX-filesystem namespace, you may want to distinguish those as two distinct paths. In that case, you can set the %SOUP_SERVER_RAW_PATHS property when creating the #SoupServer, and it will leave those characters undecoded. (You may want to call soup_uri_normalize() to decode any percent-encoded characters that you aren't handling specially.) @query contains the query component of the Request-URI parsed according to the rules for HTML form handling. Although this is the only commonly-used query string format in HTTP, there is nothing that actually requires that HTTP URIs use that format; if your server needs to use some other format, you can just ignore @query, and call soup_message_get_uri() and parse the URI's query field yourself. See soup_server_add_handler() and soup_server_add_early_handler() for details of what handlers can/should do. the #SoupServer the message being processed the path component of @msg's Request-URI the parsed query component of @msg's Request-URI additional contextual information about the client the data passed to soup_server_add_handler() or soup_server_add_early_handler(). Options to pass to soup_server_listen(), etc. %SOUP_SERVER_LISTEN_IPV4_ONLY and %SOUP_SERVER_LISTEN_IPV6_ONLY only make sense with soup_server_listen_all() and soup_server_listen_local(), not plain soup_server_listen() (which simply listens on whatever kind of socket you give it). And you cannot specify both of them in a single call. Listen for https connections rather than plain http. Only listen on IPv4 interfaces. Only listen on IPv6 interfaces. A callback used to handle WebSocket requests to a #SoupServer. The callback will be invoked after sending the handshake response back to the client (and is only invoked if the handshake was successful). @path contains the path of the Request-URI, subject to the same rules as #SoupServerCallback (qv). the #SoupServer the newly created WebSocket connection the path component of @msg's Request-URI additional contextual information about the client the data passed to @soup_server_add_handler Creates a #SoupSession with the default options. the new session. Creates a #SoupSession with the specified options. the new session. name of first property to set value of @optname1, followed by additional property/value pairs Causes @session to immediately finish processing @msg (regardless of its current state) with a final status_code of @status_code. You may call this at any time after handing @msg off to @session; if @session has started sending the request but has not yet received the complete response, then it will close the request's connection. Note that with requests that have side effects (eg, <literal>POST</literal>, <literal>PUT</literal>, <literal>DELETE</literal>) it is possible that you might cancel the request after the server acts on it, but before it returns a response, leaving the remote resource in an unknown state. If the message is cancelled while its response body is being read, then the response body in @msg will be left partially-filled-in. The response headers, on the other hand, will always be either empty or complete. Beware that with the deprecated #SoupSessionAsync, messages queued with soup_session_queue_message() will have their callbacks invoked before soup_session_cancel_message() returns. The plain #SoupSession does not have this behavior; cancelling an asynchronous message will merely queue its callback to be run after returning to the main loop. a #SoupSession the message to cancel status code to set on @msg (generally %SOUP_STATUS_CANCELLED) Queues the message @msg for asynchronously sending the request and receiving a response in the current thread-default #GMainContext. If @msg has been processed before, any resources related to the time it was last sent are freed. Upon message completion, the callback specified in @callback will be invoked. If after returning from this callback the message has not been requeued, @msg will be unreffed. (The behavior above applies to a plain #SoupSession; if you are using #SoupSessionAsync or #SoupSessionSync, then the #GMainContext that is used depends on the settings of #SoupSession:async-context and #SoupSession:use-thread-context, and for #SoupSessionSync, the message will actually be sent and processed in another thread, with only the final callback occurring in the indicated #GMainContext.) Contrast this method with soup_session_send_async(), which also asynchronously sends a message, but returns before reading the response body, and allows you to read the response via a #GInputStream. a #SoupSession the message to queue a #SoupSessionCallback which will be called after the message completes or when an unrecoverable error occurs. a pointer passed to @callback. This causes @msg to be placed back on the queue to be attempted again. a #SoupSession the message to requeue Synchronously send @msg. This call will not return until the transfer is finished successfully or there is an unrecoverable error. Unlike with soup_session_queue_message(), @msg is not freed upon return. (Note that if you call this method on a #SoupSessionAsync, it will still use asynchronous I/O internally, running the glib main loop to process the message, which may also cause other events to be processed.) Contrast this method with soup_session_send(), which also synchronously sends a message, but returns before reading the response body, and allows you to read the response via a #GInputStream. the HTTP status code of the response a #SoupSession the message to send Cancels all pending requests in @session and closes all idle persistent connections. The message cancellation has the same semantics as with soup_session_cancel_message(); asynchronous requests on a #SoupSessionAsync will have their callback called before soup_session_abort() returns. Requests on a plain #SoupSession will not. the session Adds @feature's functionality to @session. You can also add a feature to the session at construct time by using the %SOUP_SESSION_ADD_FEATURE property. See the main #SoupSession documentation for information on what features are present in sessions by default. a #SoupSession an object that implements #SoupSessionFeature If @feature_type is the type of a class that implements #SoupSessionFeature, this creates a new feature of that type and adds it to @session as with soup_session_add_feature(). You can use this when you don't need to customize the new feature in any way. If @feature_type is not a #SoupSessionFeature type, this gives each existing feature on @session the chance to accept @feature_type as a "subfeature". This can be used to add new #SoupAuth or #SoupRequest types, for instance. You can also add a feature to the session at construct time by using the %SOUP_SESSION_ADD_FEATURE_BY_TYPE property. See the main #SoupSession documentation for information on what features are present in sessions by default. a #SoupSession a #GType Causes @session to immediately finish processing @msg (regardless of its current state) with a final status_code of @status_code. You may call this at any time after handing @msg off to @session; if @session has started sending the request but has not yet received the complete response, then it will close the request's connection. Note that with requests that have side effects (eg, <literal>POST</literal>, <literal>PUT</literal>, <literal>DELETE</literal>) it is possible that you might cancel the request after the server acts on it, but before it returns a response, leaving the remote resource in an unknown state. If the message is cancelled while its response body is being read, then the response body in @msg will be left partially-filled-in. The response headers, on the other hand, will always be either empty or complete. Beware that with the deprecated #SoupSessionAsync, messages queued with soup_session_queue_message() will have their callbacks invoked before soup_session_cancel_message() returns. The plain #SoupSession does not have this behavior; cancelling an asynchronous message will merely queue its callback to be run after returning to the main loop. a #SoupSession the message to cancel status code to set on @msg (generally %SOUP_STATUS_CANCELLED) Start a connection to @uri. The operation can be monitored by providing a @progress_callback and finishes when the connection is done or an error ocurred. Call soup_session_connect_finish() to get the #GIOStream to communicate with the server. a #SoupSession a #SoupURI to connect to a #GCancellable a #SoupSessionConnectProgressCallback which will be called for every network event that occurs during the connection. the callback to invoke when the operation finishes data for @progress_callback and @callback Gets the #GIOStream created for the connection to communicate with the server. a new #GIOStream, or %NULL on error. a #SoupSession the #GAsyncResult passed to your callback Gets @session's #SoupSession:async-context. This does not add a ref to the context, so you will need to ref it yourself if you want it to outlive its session. For a modern #SoupSession, this will always just return the thread-default #GMainContext, and so is not especially useful. @session's #GMainContext, which may be %NULL a #SoupSession Gets the first feature in @session of type @feature_type. For features where there may be more than one feature of a given type, use soup_session_get_features(). a #SoupSessionFeature, or %NULL. The feature is owned by @session. a #SoupSession the #GType of the feature to get Gets the first feature in @session of type @feature_type, provided that it is not disabled for @msg. As with soup_session_get_feature(), this should only be used for features where @feature_type is only expected to match a single feature. In particular, if there are two matching features, and the first is disabled on @msg, and the second is not, then this will return %NULL, not the second feature. a #SoupSessionFeature, or %NULL. The feature is owned by @session. a #SoupSession the #GType of the feature to get a #SoupMessage Generates a list of @session's features of type @feature_type. (If you want to see all features, you can pass %SOUP_TYPE_SESSION_FEATURE for @feature_type.) a list of features. You must free the list, but not its contents a #SoupSession the #GType of the class of features to get Tests if @session has at a feature of type @feature_type (which can be the type of either a #SoupSessionFeature, or else a subtype of some class managed by another feature, such as #SoupAuth or #SoupRequest). %TRUE or %FALSE a #SoupSession the #GType of the class of features to check for Pauses HTTP I/O on @msg. Call soup_session_unpause_message() to resume I/O. This may only be called for asynchronous messages (those sent on a #SoupSessionAsync or using soup_session_queue_message()). a #SoupSession a #SoupMessage currently running on @session Tells @session that an URI from the given @hostname may be requested shortly, and so the session can try to prepare by resolving the domain name in advance, in order to work more quickly once the URI is actually requested. If @cancellable is non-%NULL, it can be used to cancel the resolution. @callback will still be invoked in this case, with a status of %SOUP_STATUS_CANCELLED. a #SoupSession a hostname to be resolved a #GCancellable object, or %NULL callback to call with the result, or %NULL data for @callback Tells @session that @uri may be requested shortly, and so the session can try to prepare (resolving the domain name, obtaining proxy address, etc.) in order to work more quickly once the URI is actually requested. use soup_session_prefetch_dns() instead a #SoupSession a #SoupURI which may be required Queues the message @msg for asynchronously sending the request and receiving a response in the current thread-default #GMainContext. If @msg has been processed before, any resources related to the time it was last sent are freed. Upon message completion, the callback specified in @callback will be invoked. If after returning from this callback the message has not been requeued, @msg will be unreffed. (The behavior above applies to a plain #SoupSession; if you are using #SoupSessionAsync or #SoupSessionSync, then the #GMainContext that is used depends on the settings of #SoupSession:async-context and #SoupSession:use-thread-context, and for #SoupSessionSync, the message will actually be sent and processed in another thread, with only the final callback occurring in the indicated #GMainContext.) Contrast this method with soup_session_send_async(), which also asynchronously sends a message, but returns before reading the response body, and allows you to read the response via a #GInputStream. a #SoupSession the message to queue a #SoupSessionCallback which will be called after the message completes or when an unrecoverable error occurs. a pointer passed to @callback. Updates @msg's URI according to its status code and "Location" header, and requeues it on @session. Use this when you have set %SOUP_MESSAGE_NO_REDIRECT on a message, but have decided to allow a particular redirection to occur, or if you want to allow a redirection that #SoupSession will not perform automatically (eg, redirecting a non-safe method such as DELETE). If @msg's status code indicates that it should be retried as a GET request, then @msg will be modified accordingly. If @msg has already been redirected too many times, this will cause it to fail with %SOUP_STATUS_TOO_MANY_REDIRECTS. %TRUE if a redirection was applied, %FALSE if not (eg, because there was no Location header, or it could not be parsed). the session a #SoupMessage that has received a 3xx response Removes @feature's functionality from @session. a #SoupSession a feature that has previously been added to @session Removes all features of type @feature_type (or any subclass of @feature_type) from @session. You can also remove standard features from the session at construct time by using the %SOUP_SESSION_REMOVE_FEATURE_BY_TYPE property. a #SoupSession a #GType Creates a #SoupRequest for retrieving @uri_string. a new #SoupRequest, or %NULL on error. a #SoupSession a URI, in string form Creates a #SoupRequest for retrieving @uri_string, which must be an "http" or "https" URI (or another protocol listed in @session's #SoupSession:http-aliases or #SoupSession:https-aliases). a new #SoupRequestHTTP, or %NULL on error. a #SoupSession an HTTP method a URI, in string form Creates a #SoupRequest for retrieving @uri, which must be an "http" or "https" URI (or another protocol listed in @session's #SoupSession:http-aliases or #SoupSession:https-aliases). a new #SoupRequestHTTP, or %NULL on error. a #SoupSession an HTTP method a #SoupURI representing the URI to retrieve Creates a #SoupRequest for retrieving @uri. a new #SoupRequest, or %NULL on error. a #SoupSession a #SoupURI representing the URI to retrieve This causes @msg to be placed back on the queue to be attempted again. a #SoupSession the message to requeue Synchronously sends @msg and waits for the beginning of a response. On success, a #GInputStream will be returned which you can use to read the response body. ("Success" here means only that an HTTP response was received and understood; it does not necessarily mean that a 2xx class status code was received.) If non-%NULL, @cancellable can be used to cancel the request; soup_session_send() will return a %G_IO_ERROR_CANCELLED error. Note that with requests that have side effects (eg, <literal>POST</literal>, <literal>PUT</literal>, <literal>DELETE</literal>) it is possible that you might cancel the request after the server acts on it, but before it returns a response, leaving the remote resource in an unknown state. If @msg is requeued due to a redirect or authentication, the initial (3xx/401/407) response body will be suppressed, and soup_session_send() will only return once a final response has been received. Contrast this method with soup_session_send_message(), which also synchronously sends a #SoupMessage, but doesn't return until the response has been completely read. (Note that this method cannot be called on the deprecated #SoupSessionAsync subclass.) a #GInputStream for reading the response body, or %NULL on error. a #SoupSession a #SoupMessage a #GCancellable Asynchronously sends @msg and waits for the beginning of a response. When @callback is called, then either @msg has been sent, and its response headers received, or else an error has occurred. Call soup_session_send_finish() to get a #GInputStream for reading the response body. See soup_session_send() for more details on the general semantics. Contrast this method with soup_session_queue_message(), which also asynchronously sends a #SoupMessage, but doesn't invoke its callback until the response has been completely read. (Note that this method cannot be called on the deprecated #SoupSessionSync subclass, and can only be called on #SoupSessionAsync if you have set the #SoupSession:use-thread-context property.) a #SoupSession a #SoupMessage a #GCancellable the callback to invoke data for @callback Gets the response to a soup_session_send_async() call and (if successful), returns a #GInputStream that can be used to read the response body. a #GInputStream for reading the response body, or %NULL on error. a #SoupSession the #GAsyncResult passed to your callback Synchronously send @msg. This call will not return until the transfer is finished successfully or there is an unrecoverable error. Unlike with soup_session_queue_message(), @msg is not freed upon return. (Note that if you call this method on a #SoupSessionAsync, it will still use asynchronous I/O internally, running the glib main loop to process the message, which may also cause other events to be processed.) Contrast this method with soup_session_send(), which also synchronously sends a message, but returns before reading the response body, and allows you to read the response via a #GInputStream. the HTTP status code of the response a #SoupSession the message to send "Steals" the HTTP connection associated with @msg from @session. This happens immediately, regardless of the current state of the connection, and @msg's callback will not be called. You can steal the connection from a #SoupMessage signal handler if you need to wait for part or all of the response to be received first. Calling this function may cause @msg to be freed if you are not holding any other reference to it. the #GIOStream formerly associated with @msg (or %NULL if @msg was no longer associated with a connection). No guarantees are made about what kind of #GIOStream is returned. a #SoupSession the message whose connection is to be stolen Resumes HTTP I/O on @msg. Use this to resume after calling soup_session_pause_message(). If @msg is being sent via blocking I/O, this will resume reading or writing immediately. If @msg is using non-blocking I/O, then reading or writing won't resume until you return to the main loop. This may only be called for asynchronous messages (those sent on a #SoupSessionAsync or using soup_session_queue_message()). a #SoupSession a #SoupMessage currently running on @session Asynchronously creates a #SoupWebsocketConnection to communicate with a remote server. All necessary WebSocket-related headers will be added to @msg, and it will then be sent and asynchronously processed normally (including handling of redirection and HTTP authentication). If the server returns "101 Switching Protocols", then @msg's status code and response headers will be updated, and then the WebSocket handshake will be completed. On success, soup_session_websocket_connect_finish() will return a new #SoupWebsocketConnection. On failure it will return a #GError. If the server returns a status other than "101 Switching Protocols", then @msg will contain the complete response headers and body from the server's response, and soup_session_websocket_connect_finish() will return %SOUP_WEBSOCKET_ERROR_NOT_WEBSOCKET. a #SoupSession #SoupMessage indicating the WebSocket server to connect to origin of the connection a %NULL-terminated array of protocols supported a #GCancellable the callback to invoke data for @callback Gets the #SoupWebsocketConnection response to a soup_session_websocket_connect_async() call and (if successful), returns a #SoupWebsocketConnection that can be used to communicate with the server. a new #SoupWebsocketConnection, or %NULL on error. a #SoupSession the #GAsyncResult passed to your callback Checks if @msg contains a response that would cause @session to redirect it to a new URL (ignoring @msg's %SOUP_MESSAGE_NO_REDIRECT flag, and the number of times it has already been redirected). whether @msg would be redirected a #SoupSession a #SoupMessage that has response headers If non-%NULL, the value to use for the "Accept-Language" header on #SoupMessage<!-- -->s sent from this session. Setting this will disable #SoupSession:accept-language-auto. If %TRUE, #SoupSession will automatically set the string for the "Accept-Language" header on every #SoupMessage sent, based on the return value of g_get_language_names(). Setting this will override any previous value of #SoupSession:accept-language. Add a feature object to the session. (Shortcut for calling soup_session_add_feature().) Add a feature object of the given type to the session. (Shortcut for calling soup_session_add_feature_by_type().) The #GMainContext that miscellaneous session-related asynchronous callbacks are invoked on. (Eg, setting #SoupSession:idle-timeout will add a timeout source on this context.) For a plain #SoupSession, this property is always set to the #GMainContext that is the thread-default at the time the session was created, and cannot be overridden. For the deprecated #SoupSession subclasses, the default value is %NULL, meaning to use the global default #GMainContext. If #SoupSession:use-thread-context is %FALSE, this context will also be used for asynchronous HTTP I/O. A %NULL-terminated array of URI schemes that should be considered to be aliases for "http". Eg, if this included <literal>"dav"</literal>, than a URI of <literal>dav://example.com/path</literal> would be treated identically to <literal>http://example.com/path</literal>. In a plain #SoupSession, the default value is %NULL, meaning that only "http" is recognized as meaning "http". In #SoupSessionAsync and #SoupSessionSync, for backward compatibility, the default value is an array containing the single element <literal>"*"</literal>, a special value which means that any scheme except "https" is considered to be an alias for "http". See also #SoupSession:https-aliases. A comma-delimited list of URI schemes that should be considered to be aliases for "https". See #SoupSession:http-aliases for more information. The default value is %NULL, meaning that no URI schemes are considered aliases for "https". Connection lifetime (in seconds) when idle. Any connection left idle longer than this will be closed. Although you can change this property at any time, it will only affect newly-created connections, not currently-open ones. You can call soup_session_abort() after setting this if you want to ensure that all future connections will have this timeout value. Note that the default value of 60 seconds only applies to plain #SoupSessions. If you are using #SoupSessionAsync or #SoupSessionSync, the default value is 0 (meaning idle connections will never time out). Sets the #SoupAddress to use for the client side of the connection. Use this property if you want for instance to bind the local socket to a specific IP address. A #GProxyResolver to use with this session. Setting this will clear the #SoupSession:proxy-uri property, and remove any <type>SoupProxyURIResolver</type> features that have been added to the session. By default, in a plain #SoupSession, this is set to the default #GProxyResolver, but you can set it to %NULL if you don't want to use proxies, or set it to your own #GProxyResolver if you want to control what proxies get used. A proxy to use for all http and https requests in this session. Setting this will clear the #SoupSession:proxy-resolver property, and remove any <type>SoupProxyURIResolver</type> features that have been added to the session. Setting this property will also cancel all currently pending messages. Note that #SoupSession will normally handle looking up the user's proxy settings for you; you should only use #SoupSession:proxy-uri if you need to override the user's normal proxy settings. Also note that this proxy will be used for <emphasis>all</emphasis> requests; even requests to <literal>localhost</literal>. If you need more control over proxies, you can create a #GSimpleProxyResolver and set the #SoupSession:proxy-resolver property. Use SoupSession:proxy-resolver along with #GSimpleProxyResolver. Remove feature objects from the session. (Shortcut for calling soup_session_remove_feature_by_type().) File containing SSL CA certificates. If the specified file does not exist or cannot be read, then libsoup will print a warning, and then behave as though it had read in a empty CA file, meaning that all SSL certificates will be considered invalid. use #SoupSession:ssl-use-system-ca-file, or else #SoupSession:tls-database with a #GTlsFileDatabase (which allows you to do explicit error handling). Normally, if #SoupSession:tls-database is set (including if it was set via #SoupSession:ssl-use-system-ca-file or #SoupSession:ssl-ca-file), then libsoup will reject any certificate that is invalid (ie, expired) or that is not signed by one of the given CA certificates, and the #SoupMessage will fail with the status %SOUP_STATUS_SSL_FAILED. If you set #SoupSession:ssl-strict to %FALSE, then all certificates will be accepted, and you will need to call soup_message_get_https_status() to distinguish valid from invalid certificates. (This can be used, eg, if you want to accept invalid certificates after giving some sort of warning.) For a plain #SoupSession, if the session has no CA file or TLS database, and this property is %TRUE, then all certificates will be rejected. However, beware that the deprecated #SoupSession subclasses (#SoupSessionAsync and #SoupSessionSync) have the opposite behavior: if there is no CA file or TLS database, then all certificates are always accepted, and this property has no effect. Setting this to %TRUE is equivalent to setting #SoupSession:tls-database to the default system CA database. (and likewise, setting #SoupSession:tls-database to the default database by hand will cause this property to become %TRUE). Setting this to %FALSE (when it was previously %TRUE) will clear the #SoupSession:tls-database field. See #SoupSession:ssl-strict for more information on how https certificate validation is handled. If you are using #SoupSessionAsync or #SoupSessionSync, on libsoup older than 2.74.0, the default value is %FALSE, for backward compatibility. The timeout (in seconds) for socket I/O operations (including connecting to a server, and waiting for a reply to an HTTP request). Although you can change this property at any time, it will only affect newly-created connections, not currently-open ones. You can call soup_session_abort() after setting this if you want to ensure that all future connections will have this timeout value. Note that the default value of 60 seconds only applies to plain #SoupSessions. If you are using #SoupSessionAsync or #SoupSessionSync, the default value is 0 (meaning socket I/O will not time out). Not to be confused with #SoupSession:idle-timeout (which is the length of time that idle persistent connections will be kept open). Sets the #GTlsDatabase to use for validating SSL/TLS certificates. Note that setting the #SoupSession:ssl-ca-file or #SoupSession:ssl-use-system-ca-file property will cause this property to be set to a #GTlsDatabase corresponding to the indicated file or system default. See #SoupSession:ssl-strict for more information on how https certificate validation is handled. If you are using a plain #SoupSession then #SoupSession:ssl-use-system-ca-file will be %TRUE by default, and so this property will be a copy of the system CA database. If you are using #SoupSessionAsync or #SoupSessionSync, on libsoup older than 2.74.0, this property will be %NULL by default. A #GTlsInteraction object that will be passed on to any #GTlsConnections created by the session. (This can be used to provide client-side certificates, for example.) Whether or not to use NTLM authentication. use soup_session_add_feature_by_type() with #SOUP_TYPE_AUTH_NTLM. If %TRUE (which it always is on a plain #SoupSession), asynchronous HTTP requests in this session will run in whatever the thread-default #GMainContext is at the time they are started, rather than always occurring in #SoupSession:async-context. If non-%NULL, the value to use for the "User-Agent" header on #SoupMessage<!-- -->s sent from this session. RFC 2616 says: "The User-Agent request-header field contains information about the user agent originating the request. This is for statistical purposes, the tracing of protocol violations, and automated recognition of user agents for the sake of tailoring responses to avoid particular user agent limitations. User agents SHOULD include this field with requests." The User-Agent header contains a list of one or more product tokens, separated by whitespace, with the most significant product token coming first. The tokens must be brief, ASCII, and mostly alphanumeric (although "-", "_", and "." are also allowed), and may optionally include a "/" followed by a version string. You may also put comments, enclosed in parentheses, between or after the tokens. If you set a #SoupSession:user_agent property that has trailing whitespace, #SoupSession will append its own product token (eg, "<literal>libsoup/2.3.2</literal>") to the end of the header for you. Emitted when the session requires authentication. If credentials are available call soup_auth_authenticate() on @auth. If these credentials fail, the signal will be emitted again, with @retrying set to %TRUE, which will continue until you return without calling soup_auth_authenticate() on @auth. Note that this may be emitted before @msg's body has been fully read. If you call soup_session_pause_message() on @msg before returning, then you can authenticate @auth asynchronously (as long as you g_object_ref() it to make sure it doesn't get destroyed), and then unpause @msg when you are ready for it to continue. the #SoupMessage being sent the #SoupAuth to authenticate %TRUE if this is the second (or later) attempt Emitted when a new connection is created. This is an internal signal intended only to be used for debugging purposes, and may go away in the future. the connection Emitted when a request is queued on @session. (Note that "queued" doesn't just mean soup_session_queue_message(); soup_session_send_message() implicitly queues the message as well.) When sending a request, first #SoupSession::request_queued is emitted, indicating that the session has become aware of the request. Once a connection is available to send the request on, the session emits #SoupSession::request_started. Then, various #SoupMessage signals are emitted as the message is processed. If the message is requeued, it will emit #SoupMessage::restarted, which will then be followed by another #SoupSession::request_started and another set of #SoupMessage signals when the message is re-sent. Eventually, the message will emit #SoupMessage::finished. Normally, this signals the completion of message processing. However, it is possible that the application will requeue the message from the "finished" handler (or equivalently, from the soup_session_queue_message() callback). In that case, the process will loop back to #SoupSession::request_started. Eventually, a message will reach "finished" and not be requeued. At that point, the session will emit #SoupSession::request_unqueued to indicate that it is done with the message. To sum up: #SoupSession::request_queued and #SoupSession::request_unqueued are guaranteed to be emitted exactly once, but #SoupSession::request_started and #SoupMessage::finished (and all of the other #SoupMessage signals) may be invoked multiple times for a given message. the request that was queued Emitted just before a request is sent. See #SoupSession::request_queued for a detailed description of the message lifecycle within a session. Use #SoupMessage::starting instead. the request being sent the socket the request is being sent on Emitted when a request is removed from @session's queue, indicating that @session is done with it. See #SoupSession::request_queued for a detailed description of the message lifecycle within a session. the request that was unqueued Emitted when an SSL tunnel is being created on a proxy connection. This is an internal signal intended only to be used for debugging purposes, and may go away in the future. the connection Creates an asynchronous #SoupSession with the default options. #SoupSessionAsync is deprecated; use a plain #SoupSession, created with soup_session_new(). See the <link linkend="libsoup-session-porting">porting guide</link>. the new session. Creates an asynchronous #SoupSession with the specified options. #SoupSessionAsync is deprecated; use a plain #SoupSession, created with soup_session_new_with_options(). See the <link linkend="libsoup-session-porting">porting guide</link>. the new session. name of first property to set value of @optname1, followed by additional property/value pairs Prototype for the callback passed to soup_session_queue_message(), qv. the session the message that has finished the data passed to soup_session_queue_message a #SoupSession the message to queue a #SoupSessionCallback which will be called after the message completes or when an unrecoverable error occurs. a pointer passed to @callback. a #SoupSession the message to requeue the HTTP status code of the response a #SoupSession the message to send a #SoupSession the message to cancel status code to set on @msg (generally %SOUP_STATUS_CANCELLED) Prototype for the progress callback passed to soup_session_connect_async(). the #SoupSession a #GSocketClientEvent the current state of the network connection the data passed to soup_session_connect_async(). An object that implement some sort of optional feature for #SoupSession. Adds a "sub-feature" of type @type to the base feature @feature. This is used for features that can be extended with multiple different types. Eg, the authentication manager can be extended with subtypes of #SoupAuth. %TRUE if @feature accepted @type as a subfeature. the "base" feature the #GType of a "sub-feature" Tests if @feature has a "sub-feature" of type @type. See soup_session_feature_add_feature(). %TRUE if @feature has a subfeature of type @type the "base" feature the #GType of a "sub-feature" Removes the "sub-feature" of type @type from the base feature @feature. See soup_session_feature_add_feature(). %TRUE if @type was removed from @feature the "base" feature the #GType of a "sub-feature" Adds a "sub-feature" of type @type to the base feature @feature. This is used for features that can be extended with multiple different types. Eg, the authentication manager can be extended with subtypes of #SoupAuth. %TRUE if @feature accepted @type as a subfeature. the "base" feature the #GType of a "sub-feature" Tests if @feature has a "sub-feature" of type @type. See soup_session_feature_add_feature(). %TRUE if @feature has a subfeature of type @type the "base" feature the #GType of a "sub-feature" Removes the "sub-feature" of type @type from the base feature @feature. See soup_session_feature_add_feature(). %TRUE if @type was removed from @feature the "base" feature the #GType of a "sub-feature" The interface implemented by #SoupSessionFeature<!-- -->s. The parent interface. %TRUE if @feature accepted @type as a subfeature. the "base" feature the #GType of a "sub-feature" %TRUE if @type was removed from @feature the "base" feature the #GType of a "sub-feature" %TRUE if @feature has a subfeature of type @type the "base" feature the #GType of a "sub-feature" Creates an synchronous #SoupSession with the default options. #SoupSessionSync is deprecated; use a plain #SoupSession, created with soup_session_new(). See the <link linkend="libsoup-session-porting">porting guide</link>. the new session. Creates an synchronous #SoupSession with the specified options. #SoupSessionSync is deprecated; use a plain #SoupSession, created with soup_session_new_with_options(). See the <link linkend="libsoup-session-porting">porting guide</link>. the new session. name of first property to set value of @optname1, followed by additional property/value pairs Creates a new (disconnected) socket the new socket name of first property to set (or %NULL) value of @optname1, followed by additional property/value pairs Begins asynchronously connecting to @sock's remote address. The socket will call @callback when it succeeds or fails (but not before returning from this function). If @cancellable is non-%NULL, it can be used to cancel the connection. @callback will still be invoked in this case, with a status of %SOUP_STATUS_CANCELLED. a client #SoupSocket (which must not already be connected) a #GCancellable, or %NULL callback to call after connecting data to pass to @callback Attempt to synchronously connect @sock to its remote address. If @cancellable is non-%NULL, it can be used to cancel the connection, in which case soup_socket_connect_sync() will return %SOUP_STATUS_CANCELLED. a success or failure code. a client #SoupSocket (which must not already be connected) a #GCancellable, or %NULL Disconnects @sock. Any further read or write attempts on it will fail. a #SoupSocket Gets @sock's underlying file descriptor. Note that fiddling with the file descriptor may break the #SoupSocket. @sock's file descriptor. a #SoupSocket Returns the #SoupAddress corresponding to the local end of @sock. Calling this method on an unconnected socket is considered to be an error, and produces undefined results. the #SoupAddress a #SoupSocket Returns the #SoupAddress corresponding to the remote end of @sock. Calling this method on an unconnected socket is considered to be an error, and produces undefined results. the #SoupAddress a #SoupSocket Tests if @sock is connected to another host %TRUE or %FALSE. a #SoupSocket Tests if @sock is doing (or has attempted to do) SSL. %TRUE if @sock has SSL credentials set a #SoupSocket Makes @sock start listening on its local address. When connections come in, @sock will emit #SoupSocket::new_connection. whether or not @sock is now listening. a server #SoupSocket (which must not already be connected or listening) Attempts to read up to @len bytes from @sock into @buffer. If some data is successfully read, soup_socket_read() will return %SOUP_SOCKET_OK, and *@nread will contain the number of bytes actually read (which may be less than @len). If @sock is non-blocking, and no data is available, the return value will be %SOUP_SOCKET_WOULD_BLOCK. In this case, the caller can connect to the #SoupSocket::readable signal to know when there is more data to read. (NB: You MUST read all available data off the socket first. #SoupSocket::readable is only emitted after soup_socket_read() returns %SOUP_SOCKET_WOULD_BLOCK, and it is only emitted once. See the documentation for #SoupSocket:non-blocking.) a #SoupSocketIOStatus, as described above (or %SOUP_SOCKET_EOF if the socket is no longer connected, or %SOUP_SOCKET_ERROR on any other error, in which case @error will also be set). the socket buffer to read into size of @buffer in bytes on return, the number of bytes read into @buffer a #GCancellable, or %NULL Like soup_socket_read(), but reads no further than the first occurrence of @boundary. (If the boundary is found, it will be included in the returned data, and *@got_boundary will be set to %TRUE.) Any data after the boundary will returned in future reads. soup_socket_read_until() will almost always return fewer than @len bytes: if the boundary is found, then it will only return the bytes up until the end of the boundary, and if the boundary is not found, then it will leave the last <literal>(boundary_len - 1)</literal> bytes in its internal buffer, in case they form the start of the boundary string. Thus, @len normally needs to be at least 1 byte longer than @boundary_len if you want to make any progress at all. as for soup_socket_read() the socket buffer to read into size of @buffer in bytes boundary to read until length of @boundary in bytes on return, the number of bytes read into @buffer on return, whether or not the data in @buffer ends with the boundary string a #GCancellable, or %NULL Starts using SSL on @socket, expecting to find a host named @ssl_host. success or failure the socket hostname of the SSL server a #GCancellable Starts using SSL on @socket. success or failure the socket a #GCancellable Attempts to write @len bytes from @buffer to @sock. If some data is successfully written, the return status will be %SOUP_SOCKET_OK, and *@nwrote will contain the number of bytes actually written (which may be less than @len). If @sock is non-blocking, and no data could be written right away, the return value will be %SOUP_SOCKET_WOULD_BLOCK. In this case, the caller can connect to the #SoupSocket::writable signal to know when more data can be written. (NB: #SoupSocket::writable is only emitted after soup_socket_write() returns %SOUP_SOCKET_WOULD_BLOCK, and it is only emitted once. See the documentation for #SoupSocket:non-blocking.) a #SoupSocketIOStatus, as described above (or %SOUP_SOCKET_EOF or %SOUP_SOCKET_ERROR. @error will be set if the return value is %SOUP_SOCKET_ERROR.) the socket data to write size of @buffer, in bytes on return, number of bytes written a #GCancellable, or %NULL Whether or not the socket is a server socket. Note that for "ordinary" #SoupSockets this will be set for both listening sockets and the sockets emitted by #SoupSocket::new-connection, but for sockets created by setting #SoupSocket:fd, it will only be set for listening sockets. Whether or not the socket uses non-blocking I/O. #SoupSocket's I/O methods are designed around the idea of using a single codepath for both synchronous and asynchronous I/O. If you want to read off a #SoupSocket, the "correct" way to do it is to call soup_socket_read() or soup_socket_read_until() repeatedly until you have read everything you want. If it returns %SOUP_SOCKET_WOULD_BLOCK at any point, stop reading and wait for it to emit the #SoupSocket::readable signal. Then go back to the reading-as-much-as-you-can loop. Likewise, for writing to a #SoupSocket, you should call soup_socket_write() either until you have written everything, or it returns %SOUP_SOCKET_WOULD_BLOCK (in which case you wait for #SoupSocket::writable and then go back into the loop). Code written this way will work correctly with both blocking and non-blocking sockets; blocking sockets will simply never return %SOUP_SOCKET_WOULD_BLOCK, and so the code that handles that case just won't get used for them. Use g_main_context_get_thread_default(). Emitted when the socket is disconnected, for whatever reason. Emitted when a network-related event occurs. See #GSocketClient::event for more details. the event that occurred the current connection state Emitted when a listening socket (set up with soup_socket_listen()) receives a new connection. You must ref the @new if you want to keep it; otherwise it will be destroyed after the signal is emitted. the new socket Emitted when an async socket is readable. See soup_socket_read(), soup_socket_read_until() and #SoupSocket:non-blocking. Emitted when an async socket is writable. See soup_socket_write() and #SoupSocket:non-blocking. The callback function passed to soup_socket_connect_async(). the #SoupSocket an HTTP status code indicating success or failure the data passed to soup_socket_connect_async() Return value from the #SoupSocket IO methods. Success Cannot read/write any more at this time End of file Other error These represent the known HTTP status code values, plus various network and internal errors. Note that no libsoup functions take or return this type directly; any function that works with status codes will accept unrecognized status codes as well. Prior to 2.44 this type was called <literal>SoupKnownStatusCode</literal>, but the individual values have always had the names they have now. No status available. (Eg, the message has not been sent yet) Message was cancelled locally Unable to resolve destination host name Unable to resolve proxy host name Unable to connect to remote host Unable to connect to proxy SSL/TLS negotiation failed A network error occurred, or the other end closed the connection unexpectedly Malformed data (usually a programmer error) Used internally There were too many redirections Used internally 100 Continue (HTTP) 101 Switching Protocols (HTTP) 102 Processing (WebDAV) 200 Success (HTTP). Also used by many lower-level soup routines to indicate success. 201 Created (HTTP) 202 Accepted (HTTP) 203 Non-Authoritative Information (HTTP) 204 No Content (HTTP) 205 Reset Content (HTTP) 206 Partial Content (HTTP) 207 Multi-Status (WebDAV) 300 Multiple Choices (HTTP) 301 Moved Permanently (HTTP) 302 Found (HTTP) 302 Moved Temporarily (old name, RFC 2068) 303 See Other (HTTP) 304 Not Modified (HTTP) 305 Use Proxy (HTTP) 306 [Unused] (HTTP) 307 Temporary Redirect (HTTP) 400 Bad Request (HTTP) 401 Unauthorized (HTTP) 402 Payment Required (HTTP) 403 Forbidden (HTTP) 404 Not Found (HTTP) 405 Method Not Allowed (HTTP) 406 Not Acceptable (HTTP) 407 Proxy Authentication Required (HTTP) shorter alias for %SOUP_STATUS_PROXY_AUTHENTICATION_REQUIRED 408 Request Timeout (HTTP) 409 Conflict (HTTP) 410 Gone (HTTP) 411 Length Required (HTTP) 412 Precondition Failed (HTTP) 413 Request Entity Too Large (HTTP) 414 Request-URI Too Long (HTTP) 415 Unsupported Media Type (HTTP) 416 Requested Range Not Satisfiable (HTTP) shorter alias for %SOUP_STATUS_REQUESTED_RANGE_NOT_SATISFIABLE 417 Expectation Failed (HTTP) 422 Unprocessable Entity (WebDAV) 423 Locked (WebDAV) 424 Failed Dependency (WebDAV) 500 Internal Server Error (HTTP) 501 Not Implemented (HTTP) 502 Bad Gateway (HTTP) 503 Service Unavailable (HTTP) 504 Gateway Timeout (HTTP) 505 HTTP Version Not Supported (HTTP) 507 Insufficient Storage (WebDAV) 510 Not Extended (RFC 2774) Looks up the stock HTTP description of @status_code. This is used by soup_message_set_status() to get the correct text to go with a given status code. <emphasis>There is no reason for you to ever use this function.</emphasis> If you wanted the textual description for the #SoupMessage:status_code of a given #SoupMessage, you should just look at the message's #SoupMessage:reason_phrase. However, you should only do that for use in debugging messages; HTTP reason phrases are not localized, and are not generally very descriptive anyway, and so they should never be presented to the user directly. Instead, you should create you own error messages based on the status code, and on what you were trying to do. the (terse, English) description of @status_code an HTTP status code Turns %SOUP_STATUS_CANT_RESOLVE into %SOUP_STATUS_CANT_RESOLVE_PROXY and %SOUP_STATUS_CANT_CONNECT into %SOUP_STATUS_CANT_CONNECT_PROXY. Other status codes are passed through unchanged. the "proxified" equivalent of @status_code. a status code Error codes for %SOUP_TLD_ERROR. A hostname was syntactically invalid. The passed-in "hostname" was actually an IP address (and thus has no base domain or public suffix). The passed-in hostname did not have enough components. Eg, calling soup_tld_get_base_domain() on <literal>"co.uk"</literal>. The passed-in hostname has no recognized public suffix. A #SoupURI represents a (parsed) URI. #SoupURI supports RFC 3986 (URI Generic Syntax), and can parse any valid URI. However, libsoup only uses "http" and "https" URIs internally; You can use SOUP_URI_VALID_FOR_HTTP() to test if a #SoupURI is a valid HTTP URI. @scheme will always be set in any URI. It is an interned string and is always all lowercase. (If you parse a URI with a non-lowercase scheme, it will be converted to lowercase.) The macros %SOUP_URI_SCHEME_HTTP and %SOUP_URI_SCHEME_HTTPS provide the interned values for "http" and "https" and can be compared against URI @scheme values. @user and @password are parsed as defined in the older URI specs (ie, separated by a colon; RFC 3986 only talks about a single "userinfo" field). Note that @password is not included in the output of soup_uri_to_string(). libsoup does not normally use these fields; authentication is handled via #SoupSession signals. @host contains the hostname, and @port the port specified in the URI. If the URI doesn't contain a hostname, @host will be %NULL, and if it doesn't specify a port, @port may be 0. However, for "http" and "https" URIs, @host is guaranteed to be non-%NULL (trying to parse an http URI with no @host will return %NULL), and @port will always be non-0 (because libsoup knows the default value to use when it is not specified in the URI). @path is always non-%NULL. For http/https URIs, @path will never be an empty string either; if the input URI has no path, the parsed #SoupURI will have a @path of "/". @query and @fragment are optional for all URI types. soup_form_decode() may be useful for parsing @query. Note that @path, @query, and @fragment may contain %<!-- -->-encoded characters. soup_uri_new() calls soup_uri_normalize() on them, but not soup_uri_decode(). This is necessary to ensure that soup_uri_to_string() will generate a URI that has exactly the same meaning as the original. (In theory, #SoupURI should leave @user, @password, and @host partially-encoded as well, but this would be more annoying than useful.) the URI scheme (eg, "http") a username, or %NULL a password, or %NULL the hostname or IP address, or %NULL the port number on @host the path on @host a query for @path, or %NULL a fragment identifier within @path, or %NULL Parses an absolute URI. You can also pass %NULL for @uri_string if you want to get back an "empty" #SoupURI that you can fill in by hand. (You will need to call at least soup_uri_set_scheme() and soup_uri_set_path(), since those fields are required.) a #SoupURI, or %NULL if the given string was found to be invalid. a URI Parses @uri_string relative to @base. a parsed #SoupURI. a base URI the URI Copies @uri a copy of @uri, which must be freed with soup_uri_free() a #SoupURI Makes a copy of @uri, considering only the protocol, host, and port the new #SoupURI a #SoupURI Tests whether or not @uri1 and @uri2 are equal in all parts %TRUE or %FALSE a #SoupURI another #SoupURI Frees @uri. a #SoupURI Gets @uri's fragment. @uri's fragment. a #SoupURI Gets @uri's host. @uri's host. a #SoupURI Gets @uri's password. @uri's password. a #SoupURI Gets @uri's path. @uri's path. a #SoupURI Gets @uri's port. @uri's port. a #SoupURI Gets @uri's query. @uri's query. a #SoupURI Gets @uri's scheme. @uri's scheme. a #SoupURI Gets @uri's user. @uri's user. a #SoupURI Compares @v1 and @v2, considering only the scheme, host, and port. whether or not the URIs are equal in scheme, host, and port. a #SoupURI with a non-%NULL @host member a #SoupURI with a non-%NULL @host member Hashes @key, considering only the scheme, host, and port. a hash a #SoupURI with a non-%NULL @host member Sets @uri's fragment to @fragment. a #SoupURI the fragment Sets @uri's host to @host. If @host is an IPv6 IP address, it should not include the brackets required by the URI syntax; they will be added automatically when converting @uri to a string. http and https URIs should not have a %NULL @host. a #SoupURI the hostname or IP address, or %NULL Sets @uri's password to @password. a #SoupURI the password, or %NULL Sets @uri's path to @path. a #SoupURI the non-%NULL path Sets @uri's port to @port. If @port is 0, @uri will not have an explicitly-specified port. a #SoupURI the port, or 0 Sets @uri's query to @query. a #SoupURI the query Sets @uri's query to the result of encoding the given form fields and values according to the * HTML form rules. See soup_form_encode() for more information. a #SoupURI name of the first form field to encode into query value of @first_field, followed by additional field names and values, terminated by %NULL. Sets @uri's query to the result of encoding @form according to the HTML form rules. See soup_form_encode_hash() for more information. a #SoupURI a #GHashTable containing HTML form information Sets @uri's scheme to @scheme. This will also set @uri's port to the default port for @scheme, if known. a #SoupURI the URI scheme Sets @uri's user to @user. a #SoupURI the username, or %NULL Returns a string representing @uri. If @just_path_and_query is %TRUE, this concatenates the path and query together. That is, it constructs the string that would be needed in the Request-Line of an HTTP request for @uri. Note that the output will never contain a password, even if @uri does. a string representing @uri, which the caller must free. a #SoupURI if %TRUE, output just the path and query portions Tests if @uri uses the default port for its scheme. (Eg, 80 for http.) (This only works for http, https and ftp; libsoup does not know the default ports of other protocols.) %TRUE or %FALSE a #SoupURI Fully %<!-- -->-decodes @part. In the past, this would return %NULL if @part contained invalid percent-encoding, but now it just ignores the problem (as soup_uri_new() already did). the decoded URI part. a URI part This %<!-- -->-encodes the given URI part and returns the escaped version in allocated memory, which the caller must free when it is done. the encoded URI part a URI part additional reserved characters to escape (or %NULL) %<!-- -->-decodes any "unreserved" characters (or characters in @unescape_extra) in @part, and %<!-- -->-encodes any non-ASCII characters, spaces, and non-printing characters in @part. "Unreserved" characters are those that are not allowed to be used for punctuation according to the URI spec. For example, letters are unreserved, so soup_uri_normalize() will turn <literal>http://example.com/foo/b%<!-- -->61r</literal> into <literal>http://example.com/foo/bar</literal>, which is guaranteed to mean the same thing. However, "/" is "reserved", so <literal>http://example.com/foo%<!-- -->2Fbar</literal> would not be changed, because it might mean something different to the server. In the past, this would return %NULL if @part contained invalid percent-encoding, but now it just ignores the problem (as soup_uri_new() already did). the normalized URI part a URI part reserved characters to unescape (or %NULL) Tests whether @uri is a valid #SoupURI; that is, that it is non-%NULL and its @scheme and @path members are also non-%NULL. This macro does not check whether http and https URIs have a non-%NULL @host member. a #SoupURI Tests if @uri is a valid #SoupURI for HTTP communication; that is, if it can be used to construct a #SoupMessage. a #SoupURI Extracts a value of type @type from @val into @args. The return value will point to the same data as @val rather than being a copy of it. Use #GVariant API instead. a #GValue a #GType #va_list pointing to a value of type pointer-to-@type Copies an argument of type @type from @args into @val. @val will point directly to the value in @args rather than copying it, so you must g_value_copy() it if you want it to remain valid. Use #GVariant API instead. a #GValue a #GType #va_list pointing to a value of type @type A macro that should be defined by the user prior to including libsoup.h. The definition should be one of the predefined libsoup version macros: %SOUP_VERSION_2_24, %SOUP_VERSION_2_26, ... This macro defines the earliest version of libsoup that the package is required to be able to compile against. If the compiler is configured to warn about the use of deprecated functions, then using functions that were deprecated in version %SOUP_VERSION_MIN_REQUIRED or earlier will cause warnings (but using functions deprecated in later releases will not). Pre-defined close codes that can be passed to soup_websocket_connection_close() or received from soup_websocket_connection_get_close_code(). (However, other codes are also allowed.) a normal, non-error close the client/server is going away a protocol error occurred the endpoint received data of a type that it does not support. reserved value indicating that no close code was present; must not be sent. reserved value indicating that the connection was closed abnormally; must not be sent. the endpoint received data that was invalid (eg, non-UTF-8 data in a text message). generic error code indicating some sort of policy violation. the endpoint received a message that is too big to process. the client is closing the connection because the server failed to negotiate a required extension. the server is closing the connection because it was unable to fulfill the request. reserved value indicating that the TLS handshake failed; must not be sent. A class representing a WebSocket connection. Creates a #SoupWebsocketConnection on @stream. This should be called after completing the handshake to begin using the WebSocket protocol. a new #SoupWebsocketConnection a #GIOStream connected to the WebSocket server the URI of the connection the type of connection (client/side) the Origin of the client the subprotocol in use Creates a #SoupWebsocketConnection on @stream with the given active @extensions. This should be called after completing the handshake to begin using the WebSocket protocol. a new #SoupWebsocketConnection a #GIOStream connected to the WebSocket server the URI of the connection the type of connection (client/side) the Origin of the client the subprotocol in use a #GList of #SoupWebsocketExtension objects Close the connection in an orderly fashion. Note that until the #SoupWebsocketConnection::closed signal fires, the connection is not yet completely closed. The close message is not even sent until the main loop runs. The @code and @data are sent to the peer along with the close request. If @code is %SOUP_WEBSOCKET_CLOSE_NO_STATUS a close message with no body (without code and data) is sent. Note that the @data must be UTF-8 valid. the WebSocket close code close data Get the close code received from the WebSocket peer. This only becomes valid once the WebSocket is in the %SOUP_WEBSOCKET_STATE_CLOSED state. The value will often be in the #SoupWebsocketCloseCode enumeration, but may also be an application defined close code. the close code or zero. the WebSocket Get the close data received from the WebSocket peer. This only becomes valid once the WebSocket is in the %SOUP_WEBSOCKET_STATE_CLOSED state. The data may be freed once the main loop is run, so copy it if you need to keep it around. the close data or %NULL the WebSocket Get the connection type (client/server) of the connection. the connection type the WebSocket Get the extensions chosen via negotiation with the peer. a #GList of #SoupWebsocketExtension objects the WebSocket Get the I/O stream the WebSocket is communicating over. the WebSocket's I/O stream. the WebSocket Gets the keepalive interval in seconds or 0 if disabled. the keepalive interval. the WebSocket Gets the maximum payload size allowed for incoming packets. the maximum payload size. the WebSocket Get the origin of the WebSocket. the origin, or %NULL the WebSocket Get the protocol chosen via negotiation with the peer. the chosen protocol, or %NULL the WebSocket Get the current state of the WebSocket. the state the WebSocket Get the URI of the WebSocket. For servers this represents the address of the WebSocket, and for clients it is the address connected to. the URI the WebSocket Send a binary message to the peer. If @length is 0, @data may be %NULL. The message is queued to be sent and will be sent when the main loop is run. the WebSocket the message contents the length of @data Send a message of the given @type to the peer. Note that this method, allows to send text messages containing %NULL characters. The message is queued to be sent and will be sent when the main loop is run. the WebSocket the type of message contents the message data as #GBytes Send a %NULL-terminated text (UTF-8) message to the peer. If you need to send text messages containing %NULL characters use soup_websocket_connection_send_message() instead. The message is queued to be sent and will be sent when the main loop is run. the WebSocket the message contents Sets the interval in seconds on when to send a ping message which will serve as a keepalive message. If set to 0 the keepalive message is disabled. the WebSocket the interval to send a ping message or 0 to disable it Sets the maximum payload size allowed for incoming packets. It does not limit the outgoing packet size. the WebSocket the maximum payload size The type of connection (client/server). List of #SoupWebsocketExtension objects that are active in the connection. The underlying IO stream the WebSocket is communicating over. The input and output streams must be pollable streams. Interval in seconds on when to send a ping message which will serve as a keepalive message. If set to 0 the keepalive message is disabled. The maximum payload size for incoming packets the protocol expects or 0 to not limit it. The client's Origin. The chosen protocol, or %NULL if a protocol was not agreed upon. The current state of the WebSocket. The URI of the WebSocket. For servers this represents the address of the WebSocket, and for clients it is the address connected to. Emitted when the connection has completely closed, either due to an orderly close from the peer, one initiated via soup_websocket_connection_close() or a fatal error condition that caused a close. This signal will be emitted once. This signal will be emitted during an orderly close. Emitted when an error occurred on the WebSocket. This may be fired multiple times. Fatal errors will be followed by the #SoupWebsocketConnection::closed signal being emitted. the error that occured Emitted when we receive a message from the peer. As a convenience, the @message data will always be NUL-terminated, but the NUL byte will not be included in the length count. the type of message contents the message data Emitted when we receive a Pong frame (solicited or unsolicited) from the peer. As a convenience, the @message data will always be NUL-terminated, but the NUL byte will not be included in the length count. the application data (if any) The abstract base class for #SoupWebsocketConnection The type of a #SoupWebsocketConnection. unknown/invalid connection a client-side connection a server-side connection The type of data contained in a #SoupWebsocketConnection::message signal. UTF-8 text binary data WebSocket-related errors. a generic error attempted to handshake with a server that does not appear to understand WebSockets. the WebSocket handshake failed because some detail was invalid (eg, incorrect accept key). the WebSocket handshake failed because the "Origin" header was not an allowed value. Configures @extension with the given @params %TRUE if extension could be configured with the given parameters, or %FALSE otherwise a #SoupWebsocketExtension either %SOUP_WEBSOCKET_CONNECTION_CLIENT or %SOUP_WEBSOCKET_CONNECTION_SERVER the parameters, or %NULL Get the parameters strings to be included in the request header. If the extension doesn't include any parameter in the request, this function returns %NULL. a new allocated string with the parameters a #SoupWebsocketExtension Get the parameters strings to be included in the response header. If the extension doesn't include any parameter in the response, this function returns %NULL. a new allocated string with the parameters a #SoupWebsocketExtension Process a message after it's received. If the payload isn't changed the given @payload is just returned, otherwise g_bytes_unref() is called on the given @payload and a new #GBytes is returned with the new data. Extensions using reserved bits of the header will reset them in @header. the message payload data, or %NULL in case of error a #SoupWebsocketExtension the message header the payload data Process a message before it's sent. If the payload isn't changed the given @payload is just returned, otherwise g_bytes_unref() is called on the given @payload and a new #GBytes is returned with the new data. Extensions using reserved bits of the header will change them in @header. the message payload data, or %NULL in case of error a #SoupWebsocketExtension the message header the payload data Configures @extension with the given @params %TRUE if extension could be configured with the given parameters, or %FALSE otherwise a #SoupWebsocketExtension either %SOUP_WEBSOCKET_CONNECTION_CLIENT or %SOUP_WEBSOCKET_CONNECTION_SERVER the parameters, or %NULL Get the parameters strings to be included in the request header. If the extension doesn't include any parameter in the request, this function returns %NULL. a new allocated string with the parameters a #SoupWebsocketExtension Get the parameters strings to be included in the response header. If the extension doesn't include any parameter in the response, this function returns %NULL. a new allocated string with the parameters a #SoupWebsocketExtension Process a message after it's received. If the payload isn't changed the given @payload is just returned, otherwise g_bytes_unref() is called on the given @payload and a new #GBytes is returned with the new data. Extensions using reserved bits of the header will reset them in @header. the message payload data, or %NULL in case of error a #SoupWebsocketExtension the message header the payload data Process a message before it's sent. If the payload isn't changed the given @payload is just returned, otherwise g_bytes_unref() is called on the given @payload and a new #GBytes is returned with the new data. Extensions using reserved bits of the header will change them in @header. the message payload data, or %NULL in case of error a #SoupWebsocketExtension the message header the payload data The class structure for the SoupWebsocketExtension. the parent class %TRUE if extension could be configured with the given parameters, or %FALSE otherwise a #SoupWebsocketExtension either %SOUP_WEBSOCKET_CONNECTION_CLIENT or %SOUP_WEBSOCKET_CONNECTION_SERVER the parameters, or %NULL a new allocated string with the parameters a #SoupWebsocketExtension a new allocated string with the parameters a #SoupWebsocketExtension the message payload data, or %NULL in case of error a #SoupWebsocketExtension the message header the payload data the message payload data, or %NULL in case of error a #SoupWebsocketExtension the message header the payload data The state of the WebSocket connection. the connection is ready to send messages the connection is in the process of closing down; messages may be received, but not sent the connection is completely closed down Pre-defined XML-RPC fault codes from <ulink url="http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php">http://xmlrpc-epi.sourceforge.net/specs/rfc.fault_codes.php</ulink>. These are an extension, not part of the XML-RPC spec; you can't assume servers will use them. request was not well-formed request was in an unsupported encoding request contained an invalid character request was not valid XML-RPC method not found invalid parameters internal error start of reserved range for application error codes start of reserved range for system error codes start of reserved range for transport error codes Opaque structure containing XML-RPC methodCall parameter values. Can be parsed using soup_xmlrpc_params_parse() and freed with soup_xmlrpc_params_free(). Free a #SoupXMLRPCParams returned by soup_xmlrpc_parse_request(). a SoupXMLRPCParams Parse method parameters returned by soup_xmlrpc_parse_request(). Deserialization details: - If @signature is provided, &lt;int&gt; and &lt;i4&gt; can be deserialized to byte, int16, uint16, int32, uint32, int64 or uint64. Otherwise it will be deserialized to int32. If the value is out of range for the target type it will return an error. - &lt;struct&gt; will be deserialized to "a{sv}". @signature could define another value type (e.g. "a{ss}"). - &lt;array&gt; will be deserialized to "av". @signature could define another element type (e.g. "as") or could be a tuple (e.g. "(ss)"). - &lt;base64&gt; will be deserialized to "ay". - &lt;string&gt; will be deserialized to "s". - &lt;dateTime.iso8601&gt; will be deserialized to an unspecified variant type. If @signature is provided it must have the generic "v" type, which means there is no guarantee that it's actually a datetime that has been received. soup_xmlrpc_variant_get_datetime() must be used to parse and type check this special variant. - @signature must not have maybes, otherwise an error is returned. - Dictionaries must have string keys, otherwise an error is returned. a new (non-floating) #GVariant, or %NULL A #SoupXMLRPCParams A valid #GVariant type string, or %NULL Adds @function to be executed from inside @async_context with the default priority. Use this when you want to complete an action in @async_context's main loop, as soon as possible. a #GSource, which can be removed from @async_context with g_source_destroy(). the #GMainContext to dispatch the I/O watch in, or %NULL for the default context the callback to invoke user data to pass to @function Adds an idle event as with g_idle_add(), but using the given @async_context. If you want @function to run "right away", use soup_add_completion(), since that sets a higher priority on the #GSource than soup_add_idle() does. a #GSource, which can be removed from @async_context with g_source_destroy(). the #GMainContext to dispatch the I/O watch in, or %NULL for the default context the callback to invoke at idle time user data to pass to @function Adds an I/O watch as with g_io_add_watch(), but using the given @async_context. a #GSource, which can be removed from @async_context with g_source_destroy(). the #GMainContext to dispatch the I/O watch in, or %NULL for the default context the #GIOChannel to watch the condition to watch for the callback to invoke when @condition occurs user data to pass to @function Adds a timeout as with g_timeout_add(), but using the given @async_context. a #GSource, which can be removed from @async_context with g_source_destroy(). the #GMainContext to dispatch the I/O watch in, or %NULL for the default context the timeout interval, in milliseconds the callback to invoke at timeout time user data to pass to @function Like SOUP_CHECK_VERSION, but the check for soup_check_version is at runtime instead of compile time. This is useful for compiling against older versions of libsoup, but using features from newer versions. %TRUE if the version of the libsoup currently loaded is the same as or newer than the passed-in version. the major version to check the minor version to check the micro version to check Parses @header and returns a #SoupCookie. (If @header contains multiple cookies, only the first one will be parsed.) If @header does not have "path" or "domain" attributes, they will be defaulted from @origin. If @origin is %NULL, path will default to "/", but domain will be left as %NULL. Note that this is not a valid state for a #SoupCookie, and you will need to fill in some appropriate string for the domain if you want to actually make use of the cookie. a new #SoupCookie, or %NULL if it could not be parsed, or contained an illegal "domain" attribute for a cookie originating from @origin. a cookie string (eg, the value of a Set-Cookie header) origin of the cookie, or %NULL Frees @cookies. a #GSList of #SoupCookie Parses @msg's Cookie request header and returns a #GSList of #SoupCookie<!-- -->s. As the "Cookie" header, unlike "Set-Cookie", only contains cookie names and values, none of the other #SoupCookie fields will be filled in. (Thus, you can't generally pass a cookie returned from this method directly to soup_cookies_to_response().) a #GSList of #SoupCookie<!-- -->s, which can be freed with soup_cookies_free(). a #SoupMessage containing a "Cookie" request header Parses @msg's Set-Cookie response headers and returns a #GSList of #SoupCookie<!-- -->s. Cookies that do not specify "path" or "domain" attributes will have their values defaulted from @msg. a #GSList of #SoupCookie<!-- -->s, which can be freed with soup_cookies_free(). a #SoupMessage containing a "Set-Cookie" response header Serializes a #GSList of #SoupCookie into a string suitable for setting as the value of the "Cookie" header. the serialization of @cookies a #GSList of #SoupCookie Adds the name and value of each cookie in @cookies to @msg's "Cookie" request. (If @msg already has a "Cookie" request header, these cookies will be appended to the cookies already present. Be careful that you do not append the same cookies twice, eg, when requeuing a message.) a #GSList of #SoupCookie a #SoupMessage Appends a "Set-Cookie" response header to @msg for each cookie in @cookies. (This is in addition to any other "Set-Cookie" headers @msg may already have.) a #GSList of #SoupCookie a #SoupMessage Decodes @form, which is an urlencoded dataset as defined in the HTML 4.01 spec. a hash table containing the name/value pairs from @encoded_form, which you can free with g_hash_table_destroy(). data of type "application/x-www-form-urlencoded" 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. (Or when you don't have any file upload controls, but are still using "multipart/form-data" anyway.) Pass the name of the file upload control in @file_control_name, and soup_form_decode_multipart() will extract the uploaded file data into @filename, @content_type, and @file. All of the other form control data will be returned (as strings, as with soup_form_decode()) in the returned #GHashTable. You may pass %NULL for @filename, @content_type and/or @file if you do not care about those fields. soup_form_decode_multipart() may also return %NULL in those fields if the client did not provide that information. You must free the returned filename and content-type with g_free(), and the returned file data with soup_buffer_free(). If you have a form with more than one file upload control, you will need to decode it manually, using soup_multipart_new_from_message() and soup_multipart_get_part(). a hash table containing the name/value pairs (other than @file_control_name) from @msg, which you can free with g_hash_table_destroy(). On error, it will return %NULL. a #SoupMessage containing a "multipart/form-data" request body the name of the HTML file upload control, or %NULL return location for the name of the uploaded file, or %NULL return location for the MIME type of the uploaded file, or %NULL return location for the uploaded file data, or %NULL Encodes the given field names and values into a value of type "application/x-www-form-urlencoded", as defined in the HTML 4.01 spec. This method requires you to know the names of the form fields (or at the very least, the total number of fields) at compile time; for working with dynamic forms, use soup_form_encode_hash() or soup_form_encode_datalist(). the encoded form name of the first form field value of @first_field, followed by additional field names and values, terminated by %NULL. Encodes @form_data_set into a value of type "application/x-www-form-urlencoded", as defined in the HTML 4.01 spec. Unlike soup_form_encode_hash(), this preserves the ordering of the form elements, which may be required in some situations. the encoded form a datalist containing name/value pairs Encodes @form_data_set into a value of type "application/x-www-form-urlencoded", as defined in the HTML 4.01 spec. Note that the HTML spec states that "The control names/values are listed in the order they appear in the document." Since this method takes a hash table, it cannot enforce that; if you care about the ordering of the form fields, use soup_form_encode_datalist(). the encoded form a hash table containing name/value pairs (as strings) See soup_form_encode(). This is mostly an internal method, used by various other methods such as soup_uri_set_query_from_fields() and soup_form_request_new(). the encoded form name of the first form field pointer to additional values, as in soup_form_encode() Creates a new %SoupMessage and sets it up to send the given data to @uri via @method. (That is, if @method is "GET", it will encode the form data into @uri's query field, and if @method is "POST", it will encode it into the %SoupMessage's request_body.) the new %SoupMessage the HTTP method, either "GET" or "POST" the URI to send the form data to name of the first form field value of @first_field, followed by additional field names and values, terminated by %NULL. Creates a new %SoupMessage and sets it up to send @form_data_set to @uri via @method, as with soup_form_request_new(). the new %SoupMessage the HTTP method, either "GET" or "POST" the URI to send the form data to the data to send to @uri Creates a new %SoupMessage and sets it up to send @form_data_set to @uri via @method, as with soup_form_request_new(). the new %SoupMessage the HTTP method, either "GET" or "POST" the URI to send the form data to the data to send to @uri Creates a new %SoupMessage and sets it up to send @multipart to @uri via POST. To send a <literal>"multipart/form-data"</literal> POST, first create a #SoupMultipart, using %SOUP_FORM_MIME_TYPE_MULTIPART as the MIME type. Then use soup_multipart_append_form_string() and soup_multipart_append_form_file() to add the value of each form control to the multipart. (These are just convenience methods, and you can use soup_multipart_append_part() if you need greater control over the part headers.) Finally, call soup_form_request_new_from_multipart() to serialize the multipart structure and create a #SoupMessage. the new %SoupMessage the URI to send the form data to a "multipart/form-data" #SoupMultipart Returns the major version number of the libsoup library. (e.g. in libsoup version 2.42.0 this is 2.) This function is in the library, so it represents the libsoup library your code is running against. Contrast with the #SOUP_MAJOR_VERSION macro, which represents the major version of the libsoup headers you have included when compiling your code. the major version number of the libsoup library Returns the micro version number of the libsoup library. (e.g. in libsoup version 2.42.0 this is 0.) This function is in the library, so it represents the libsoup library your code is running against. Contrast with the #SOUP_MICRO_VERSION macro, which represents the micro version of the libsoup headers you have included when compiling your code. the micro version number of the libsoup library Returns the minor version number of the libsoup library. (e.g. in libsoup version 2.42.0 this is 42.) This function is in the library, so it represents the libsoup library your code is running against. Contrast with the #SOUP_MINOR_VERSION macro, which represents the minor version of the libsoup headers you have included when compiling your code. the minor version number of the libsoup library Parses @header to see if it contains the token @token (matched case-insensitively). Note that this can't be used with lists that have qvalues. whether or not @header contains @token An HTTP header suitable for parsing with soup_header_parse_list() a token Frees @list. a #GSList returned from soup_header_parse_list() or soup_header_parse_quality_list() Frees @param_list. a #GHashTable returned from soup_header_parse_param_list() or soup_header_parse_semi_param_list() Appends something like <literal>@name=@value</literal> to @string, taking care to quote @value if needed, and if so, to escape any quotes or backslashes in @value. Alternatively, if @value is a non-ASCII UTF-8 string, it will be appended using RFC5987 syntax. Although in theory this is supposed to work anywhere in HTTP that uses this style of parameter, in reality, it can only be used portably with the Content-Disposition "filename" parameter. If @value is %NULL, this will just append @name to @string. a #GString being used to construct an HTTP header value a parameter name a parameter value, or %NULL Appends something like <literal>@name="@value"</literal> to @string, taking care to escape any quotes or backslashes in @value. If @value is (non-ASCII) UTF-8, this will instead use RFC 5987 encoding, just like soup_header_g_string_append_param(). a #GString being used to construct an HTTP header value a parameter name a parameter value Parses a header whose content is described by RFC2616 as "#something", where "something" does not itself contain commas, except as part of quoted-strings. a #GSList of list elements, as allocated strings a header value Parses a header which is a comma-delimited list of something like: <literal>token [ "=" ( token | quoted-string ) ]</literal>. Tokens that don't have an associated value will still be added to the resulting hash table, but with a %NULL value. This also handles RFC5987 encoding (which in HTTP is mostly used for giving UTF8-encoded filenames in the Content-Disposition header). a #GHashTable of list elements, which can be freed with soup_header_free_param_list(). a header value A strict version of soup_header_parse_param_list() that bails out if there are duplicate parameters. Note that this function will treat RFC5987-encoded parameters as duplicated if an ASCII version is also present. For header fields that might contain RFC5987-encoded parameters, use soup_header_parse_param_list() instead. a #GHashTable of list elements, which can be freed with soup_header_free_param_list() or %NULL if there are duplicate elements. a header value Parses a header whose content is a list of items with optional "qvalue"s (eg, Accept, Accept-Charset, Accept-Encoding, Accept-Language, TE). If @unacceptable is not %NULL, then on return, it will contain the items with qvalue 0. Either way, those items will be removed from the main list. a #GSList of acceptable values (as allocated strings), highest-qvalue first. a header value on return, will contain a list of unacceptable values Parses a header which is a semicolon-delimited list of something like: <literal>token [ "=" ( token | quoted-string ) ]</literal>. Tokens that don't have an associated value will still be added to the resulting hash table, but with a %NULL value. This also handles RFC5987 encoding (which in HTTP is mostly used for giving UTF8-encoded filenames in the Content-Disposition header). a #GHashTable of list elements, which can be freed with soup_header_free_param_list(). a header value A strict version of soup_header_parse_semi_param_list() that bails out if there are duplicate parameters. Note that this function will treat RFC5987-encoded parameters as duplicated if an ASCII version is also present. For header fields that might contain RFC5987-encoded parameters, use soup_header_parse_semi_param_list() instead. a #GHashTable of list elements, which can be freed with soup_header_free_param_list() or %NULL if there are duplicate elements. a header value Parses the headers of an HTTP request or response in @str and stores the results in @dest. Beware that @dest may be modified even on failure. This is a low-level method; normally you would use soup_headers_parse_request() or soup_headers_parse_response(). success or failure the header string (including the Request-Line or Status-Line, but not the trailing blank line) length of @str #SoupMessageHeaders to store the header values in Parses the headers of an HTTP request in @str and stores the results in @req_method, @req_path, @ver, and @req_headers. Beware that @req_headers may be modified even on failure. %SOUP_STATUS_OK if the headers could be parsed, or an HTTP error to be returned to the client if they could not be. the headers (up to, but not including, the trailing blank line) length of @str #SoupMessageHeaders to store the header values in if non-%NULL, will be filled in with the request method if non-%NULL, will be filled in with the request path if non-%NULL, will be filled in with the HTTP version Parses the headers of an HTTP response in @str and stores the results in @ver, @status_code, @reason_phrase, and @headers. Beware that @headers may be modified even on failure. success or failure. the headers (up to, but not including, the trailing blank line) length of @str #SoupMessageHeaders to store the header values in if non-%NULL, will be filled in with the HTTP version if non-%NULL, will be filled in with the status code if non-%NULL, will be filled in with the reason phrase Parses the HTTP Status-Line string in @status_line into @ver, @status_code, and @reason_phrase. @status_line must be terminated by either "\0" or "\r\n". %TRUE if @status_line was parsed successfully. an HTTP Status-Line if non-%NULL, will be filled in with the HTTP version if non-%NULL, will be filled in with the status code if non-%NULL, will be filled in with the reason phrase Initializes @iter for iterating @hdrs. a pointer to a %SoupMessageHeadersIter structure a %SoupMessageHeaders #SoupAddress represents the address of a TCP connection endpoint: both the IP address and the port. (It is somewhat like an object-oriented version of struct sockaddr.) Although #SoupAddress is still used in some libsoup API's, it should not be used in new code; use GLib's #GNetworkAddress or #GSocketAddress instead. #SoupAuth objects store the authentication data associated with a given bit of web space. They are created automatically by #SoupSession. A #SoupAuthDomain manages authentication for all or part of a #SoupServer. To make a server require authentication, first create an appropriate subclass of #SoupAuthDomain, and then add it to the server with soup_server_add_auth_domain(). In order for an auth domain to have any effect, you must add one or more paths to it (via soup_auth_domain_add_path() or the %SOUP_AUTH_DOMAIN_ADD_PATH property). To require authentication for all ordinary requests, add the path "/". (Note that this does not include the special "*" URI (eg, "OPTIONS *"), which must be added as a separate path if you want to cover it.) If you need greater control over which requests should and shouldn't be authenticated, add paths covering everything you <emphasis>might</emphasis> want authenticated, and then use a filter (soup_auth_domain_set_filter()) to bypass authentication for those requests that don't need it. #SoupAuthDomainBasic handles the server side of HTTP "Basic" (ie, cleartext password) authentication. #SoupAuthDomainDigest handles the server side of HTTP "Digest" authentication. #SoupAuthManager is the #SoupSessionFeature that handles HTTP authentication for a #SoupSession. A #SoupAuthManager is added to the session by default, and normally you don't need to worry about it at all. However, if you want to disable HTTP authentication, you can remove the feature from the session with soup_session_remove_feature_by_type(), or disable it on individual requests with soup_message_disable_feature(). #SoupCache implements a file-based cache for HTTP resources. #SoupContentDecoder handles adding the "Accept-Encoding" header on outgoing messages, and processing the "Content-Encoding" header on incoming ones. Currently it supports the "gzip", "deflate", and "br" content codings. If you are using a plain #SoupSession (ie, not #SoupSessionAsync or #SoupSessionSync), then a #SoupContentDecoder will automatically be added to the session by default. (You can use %SOUP_SESSION_REMOVE_FEATURE_BY_TYPE at construct time if you don't want this.) If you are using one of the deprecated #SoupSession subclasses, you can add a #SoupContentDecoder to your session with soup_session_add_feature() or soup_session_add_feature_by_type(). If #SoupContentDecoder successfully decodes the Content-Encoding, it will set the %SOUP_MESSAGE_CONTENT_DECODED flag on the message, and the message body and the chunks in the #SoupMessage::got_chunk signals will contain the decoded data; however, the message headers will be unchanged (and so "Content-Encoding" will still be present, "Content-Length" will describe the original encoded length, etc). If "Content-Encoding" contains any encoding types that #SoupContentDecoder doesn't recognize, then none of the encodings will be decoded (and the %SOUP_MESSAGE_CONTENT_DECODED flag will not be set). (Note that currently there is no way to (automatically) use Content-Encoding when sending a request body, or to pick specific encoding types to support.) A #SoupContentSniffer tries to detect the actual content type of the files that are being downloaded by looking at some of the data before the #SoupMessage emits its #SoupMessage::got-headers signal. #SoupContentSniffer implements #SoupSessionFeature, so you can add content sniffing to a session with soup_session_add_feature() or soup_session_add_feature_by_type(). #SoupCookie implements HTTP cookies, as described by <ulink url="http://tools.ietf.org/html/rfc6265.txt">RFC 6265</ulink>. To have a #SoupSession handle cookies for your appliction automatically, use a #SoupCookieJar. A #SoupCookieJar stores #SoupCookie<!-- -->s and arrange for them to be sent with the appropriate #SoupMessage<!-- -->s. #SoupCookieJar implements #SoupSessionFeature, so you can add a cookie jar to a session with soup_session_add_feature() or soup_session_add_feature_by_type(). Note that the base #SoupCookieJar class does not support any form of long-term cookie persistence. #SoupCookieJarDB is a #SoupCookieJar that reads cookies from and writes them to a sqlite database in the new Mozilla format. (This is identical to <literal>SoupCookieJarSqlite</literal> in libsoup-gnome; it has just been moved into libsoup proper, and renamed to avoid conflicting.) #SoupCookieJarText is a #SoupCookieJar that reads cookies from and writes them to a text file in the Mozilla "cookies.txt" format. libsoup contains several help methods for processing HTML forms as defined by <ulink url="http://www.w3.org/TR/html401/interact/forms.html#h-17.13">the HTML 4.01 specification</ulink>. A #SoupHSTSEnforcer stores HSTS policies and enforces them when required. #SoupHSTSEnforcer implements #SoupSessionFeature, so you can add an HSTS enforcer to a session with soup_session_add_feature() or soup_session_add_feature_by_type(). #SoupHSTSEnforcer keeps track of all the HTTPS destinations that, when connected to, return the Strict-Transport-Security header with valid values. #SoupHSTSEnforcer will forget those destinations upon expiry or when the server requests it. When the #SoupSession the #SoupHSTSEnforcer is attached to queues or restarts a message, the #SoupHSTSEnforcer will rewrite the URI to HTTPS if the destination is a known HSTS host and is contacted over an insecure transport protocol (HTTP). Users of #SoupHSTSEnforcer are advised to listen to changes in SoupMessage:uri in order to be aware of changes in the message URI. Note that #SoupHSTSEnforcer does not support any form of long-term HSTS policy persistence. See #SoupHSTSDBEnforcer for a persistent enforcer. #SoupHSTSEnforcerDB is a #SoupHSTSEnforcer that uses a SQLite database as a backend for persistency. #SoupHSTSPolicy implements HTTP policies, as described by <ulink url="http://tools.ietf.org/html/rfc6797">RFC 6797</ulink>. To have a #SoupSession handle HSTS policies for your appliction automatically, use a #SoupHSTSEnforcer. #SoupLogger watches a #SoupSession and logs the HTTP traffic that it generates, for debugging purposes. Many applications use an environment variable to determine whether or not to use #SoupLogger, and to determine the amount of debugging output. To use #SoupLogger, first create a logger with soup_logger_new(), optionally configure it with soup_logger_set_request_filter(), soup_logger_set_response_filter(), and soup_logger_set_printer(), and then attach it to a session (or multiple sessions) with soup_session_add_feature(). By default, the debugging output is sent to <literal>stdout</literal>, and looks something like: <informalexample><screen> > POST /unauth HTTP/1.1 > Soup-Debug-Timestamp: 1200171744 > Soup-Debug: SoupSessionAsync 1 (0x612190), SoupMessage 1 (0x617000), SoupSocket 1 (0x612220) > Host: localhost > Content-Type: text/plain > Connection: close > > This is a test. &lt; HTTP/1.1 201 Created &lt; Soup-Debug-Timestamp: 1200171744 &lt; Soup-Debug: SoupMessage 1 (0x617000) &lt; Date: Sun, 12 Jan 2008 21:02:24 GMT &lt; Content-Length: 0 </screen></informalexample> The <literal>Soup-Debug-Timestamp</literal> line gives the time (as a <type>time_t</type>) when the request was sent, or the response fully received. The <literal>Soup-Debug</literal> line gives further debugging information about the #SoupSession, #SoupMessage, and #SoupSocket involved; the hex numbers are the addresses of the objects in question (which may be useful if you are running in a debugger). The decimal IDs are simply counters that uniquely identify objects across the lifetime of the #SoupLogger. In particular, this can be used to identify when multiple messages are sent across the same connection. Currently, the request half of the message is logged just before the first byte of the request gets written to the network (from the #SoupMessage::starting signal), which means that if you have not made the complete request body available at that point, it will not be logged. The response is logged just after the last byte of the response body is read from the network (from the #SoupMessage::got_body or #SoupMessage::got_informational signal), which means that the #SoupMessage::got_headers signal, and anything triggered off it (such as #SoupSession::authenticate) will be emitted <emphasis>before</emphasis> the response headers are actually logged. If the response doesn't happen to trigger the #SoupMessage::got_body nor #SoupMessage::got_informational signals due to, for example, a cancellation before receiving the last byte of the response body, the response will still be logged on the event of the #SoupMessage::finished signal. A #SoupMessage represents an HTTP message that is being sent or received. For client-side usage, if you are using the traditional #SoupSession APIs (soup_session_queue_message() and soup_session_send_message()), you would create a #SoupMessage with soup_message_new() or soup_message_new_from_uri(), set up its fields appropriately, and send it. If you are using the newer #SoupRequest API, you would create a request with soup_session_request_http() or soup_session_request_http_uri(), and the returned #SoupRequestHTTP will already have an associated #SoupMessage that you can retrieve via soup_request_http_get_message(). For server-side usage, #SoupServer will create #SoupMessage<!-- -->s automatically for incoming requests, which your application will receive via handlers. Note that libsoup's terminology here does not quite match the HTTP specification: in RFC 2616, an "HTTP-message" is <emphasis>either</emphasis> a Request, <emphasis>or</emphasis> a Response. In libsoup, a #SoupMessage combines both the request and the response. #SoupMessageBody represents the request or response body of a #SoupMessage. In addition to #SoupMessageBody, libsoup also defines a "smaller" data buffer type, #SoupBuffer, which is primarily used as a component of #SoupMessageBody. In particular, when using chunked encoding to transmit or receive a message, each chunk is represented as a #SoupBuffer. #SoupMessageHeaders represents the HTTP message headers associated with a request or response. soup-method.h contains a number of defines for standard HTTP and WebDAV headers. You do not need to use these defines; you can pass arbitrary strings to soup_message_new() if you prefer. The thing that these defines <emphasis>are</emphasis> useful for is performing quick comparisons against #SoupMessage's %method field; because that field always contains an interned string, and these macros return interned strings, you can compare %method directly against these macros rather than needing to use strcmp(). This is most useful in SoupServer handlers. Eg: <informalexample><programlisting> if (msg->method != SOUP_METHOD_GET &amp;&amp; msg->method != SOUP_METHOD_HEAD) { soup_message_set_status (msg, SOUP_METHOD_NOT_IMPLEMENTED); return; } </programlisting></informalexample> This adds support for the multipart responses. For handling the multiple parts the user needs to wrap the #GInputStream obtained by sending the request with a #SoupMultipartInputStream and use soup_multipart_input_stream_next_part() before reading. Responses which are not wrapped will be treated like non-multipart responses. Note that although #SoupMultipartInputStream is a #GInputStream, you should not read directly from it, and the results are undefined if you do. #SoupProxyResolverDefault is a <type>SoupProxyURIResolver</type> implementation that uses the default gio #GProxyResolver to resolve proxies. In libsoup 2.44 and later, you can set the session's #SoupSession:proxy-resolver property to the resolver returned by g_proxy_resolver_get_default() to get the same effect. Note that for "plain" #SoupSessions (ie, not #SoupSessionAsync or #SoupSessionSync), this is done for you automatically. #SoupProxyURIResolver is an interface for finding appropriate HTTP proxies to use. A #SoupRequest is created by #SoupSession, and represents a request to retrieve a particular URI. #SoupRequestData implements #SoupRequest for "data" URIs. #SoupRequestFile implements #SoupRequest for "file" and "resource" URIs. #SoupRequestHTTP implements #SoupRequest for "http" and "https" URIs. To do more complicated HTTP operations using the #SoupRequest APIs, call soup_request_http_get_message() to get the request's #SoupMessage. #SoupServer implements a simple HTTP server. (The following documentation describes the current #SoupServer API, available in <application>libsoup</application> 2.48 and later. See the section "<link linkend="soup-server-old-api">The Old SoupServer Listening API</link>" in the server how-to documentation for details on the older #SoupServer API.) To begin, create a server using soup_server_new(). Add at least one handler by calling soup_server_add_handler() or soup_server_add_early_handler(); the handler will be called to process any requests underneath the path you pass. (If you want all requests to go to the same handler, just pass "/" (or %NULL) for the path.) When a new connection is accepted (or a new request is started on an existing persistent connection), the #SoupServer will emit #SoupServer::request-started and then begin processing the request as described below, but note that once the message is assigned a #SoupMessage:status-code, then callbacks after that point will be skipped. Note also that it is not defined when the callbacks happen relative to various #SoupMessage signals. Once the headers have been read, #SoupServer will check if there is a #SoupAuthDomain (qv) covering the Request-URI; if so, and if the message does not contain suitable authorization, then the #SoupAuthDomain will set a status of %SOUP_STATUS_UNAUTHORIZED on the message. After checking for authorization, #SoupServer will look for "early" handlers (added with soup_server_add_early_handler()) matching the Request-URI. If one is found, it will be run; in particular, this can be used to connect to signals to do a streaming read of the request body. (At this point, if the request headers contain "<literal>Expect: 100-continue</literal>", and a status code has been set, then #SoupServer will skip the remaining steps and return the response. If the request headers contain "<literal>Expect: 100-continue</literal>" and no status code has been set, #SoupServer will return a %SOUP_STATUS_CONTINUE status before continuing.) The server will then read in the response body (if present). At this point, if there are no handlers at all defined for the Request-URI, then the server will return %SOUP_STATUS_NOT_FOUND to the client. Otherwise (assuming no previous step assigned a status to the message) any "normal" handlers (added with soup_server_add_handler()) for the message's Request-URI will be run. Then, if the path has a WebSocket handler registered (and has not yet been assigned a status), #SoupServer will attempt to validate the WebSocket handshake, filling in the response and setting a status of %SOUP_STATUS_SWITCHING_PROTOCOLS or %SOUP_STATUS_BAD_REQUEST accordingly. If the message still has no status code at this point (and has not been paused with soup_server_pause_message()), then it will be given a status of %SOUP_STATUS_INTERNAL_SERVER_ERROR (because at least one handler ran, but returned without assigning a status). Finally, the server will emit #SoupServer::request-finished (or #SoupServer::request-aborted if an I/O error occurred before handling was completed). If you want to handle the special "*" URI (eg, "OPTIONS *"), you must explicitly register a handler for "*"; the default handler will not be used for that case. If you want to process https connections in addition to (or instead of) http connections, you can either set the %SOUP_SERVER_TLS_CERTIFICATE property when creating the server, or else call soup_server_set_ssl_certificate() after creating it. Once the server is set up, make one or more calls to soup_server_listen(), soup_server_listen_local(), or soup_server_listen_all() to tell it where to listen for connections. (All ports on a #SoupServer use the same handlers; if you need to handle some ports differently, such as returning different data for http and https, you'll need to create multiple #SoupServers, or else check the passed-in URI in the handler function.). #SoupServer will begin processing connections as soon as you return to (or start) the main loop for the current thread-default #GMainContext. #SoupSession is the object that controls client-side HTTP. A #SoupSession encapsulates all of the state that libsoup is keeping on behalf of your program; cached HTTP connections, authentication information, etc. It also keeps track of various global options and features that you are using. Most applications will only need a single #SoupSession; the primary reason you might need multiple sessions is if you need to have multiple independent authentication contexts. (Eg, you are connecting to a server and authenticating as two different users at different times; the easiest way to ensure that each #SoupMessage is sent with the authentication information you intended is to use one session for the first user, and a second session for the other user.) In the past, #SoupSession was an abstract class, and users needed to choose between #SoupSessionAsync (which always uses #GMainLoop<!-- -->-based I/O), or #SoupSessionSync (which always uses blocking I/O and can be used from multiple threads simultaneously). This is no longer necessary; you can (and should) use a plain #SoupSession, which supports both synchronous and asynchronous use. (When using a plain #SoupSession, soup_session_queue_message() behaves like it traditionally did on a #SoupSessionAsync, and soup_session_send_message() behaves like it traditionally did on a #SoupSessionSync.) Additional #SoupSession functionality is provided by #SoupSessionFeature objects, which can be added to a session with soup_session_add_feature() or soup_session_add_feature_by_type() (or at construct time with the %SOUP_SESSION_ADD_FEATURE_BY_TYPE pseudo-property). For example, #SoupLogger provides support for logging HTTP traffic, #SoupContentDecoder provides support for compressed response handling, and #SoupContentSniffer provides support for HTML5-style response body content sniffing. Additionally, subtypes of #SoupAuth and #SoupRequest can be added as features, to add support for additional authentication and URI types. All #SoupSessions are created with a #SoupAuthManager, and support for %SOUP_TYPE_AUTH_BASIC and %SOUP_TYPE_AUTH_DIGEST. For #SoupRequest types, #SoupRequestHTTP, #SoupRequestFile, and #SoupRequestData are supported. Additionally, sessions using the plain #SoupSession class (rather than one of its deprecated subtypes) have a #SoupContentDecoder by default. #SoupSessionAsync is an implementation of #SoupSession that uses non-blocking I/O via the glib main loop for all I/O. #SoupSessionFeature is the interface used by classes that extend the functionality of a #SoupSession. Some features like HTTP authentication handling are implemented internally via #SoupSessionFeature<!-- -->s. Other features can be added to the session by the application. (Eg, #SoupLogger, #SoupCookieJar.) See soup_session_add_feature(), etc, to add a feature to a session. #SoupSessionSync is an implementation of #SoupSession that uses synchronous I/O, intended for use in multi-threaded programs. #SoupSocket is libsoup's TCP socket type. While it is primarily intended for internal use, #SoupSocket<!-- -->s are exposed in the API in various places, and some of their methods (eg, soup_socket_get_remote_address()) may be useful to applications. These functions can be used to parse hostnames to attempt to determine what part of the name belongs to the domain owner, and what part is simply a "public suffix" such as ".com". A #SoupURI represents a (parsed) URI. Many applications will not need to use #SoupURI directly at all; on the client side, soup_message_new() takes a stringified URI, and on the server side, the path and query components are provided for you in the server callback. These methods are useful for manipulating #GValue<!-- -->s, and in particular, arrays and hash tables of #GValue<!-- -->s, in a slightly nicer way than the standard #GValue API. They are written for use with soup-xmlrpc, but they also work with types not used by XML-RPC. #SoupWebsocketConnection provides support for the <ulink url="http://tools.ietf.org/html/rfc6455">WebSocket</ulink> protocol. To connect to a WebSocket server, create a #SoupSession and call soup_session_websocket_connect_async(). To accept WebSocket connections, create a #SoupServer and add a handler to it with soup_server_add_websocket_handler(). (Lower-level support is available via soup_websocket_client_prepare_handshake() and soup_websocket_client_verify_handshake(), for handling the client side of the WebSocket handshake, and soup_websocket_server_process_handshake() for handling the server side.) #SoupWebsocketConnection handles the details of WebSocket communication. You can use soup_websocket_connection_send_text() and soup_websocket_connection_send_binary() to send data, and the #SoupWebsocketConnection::message signal to receive data. (#SoupWebsocketConnection currently only supports asynchronous I/O.) SoupWebsocketExtension is the base class for WebSocket extension objects. SoupWebsocketExtensionManager is the #SoupSessionFeature that handles WebSockets extensions for a #SoupSession. A SoupWebsocketExtensionManager is added to the session by default, and normally you don't need to worry about it at all. However, if you want to disable WebSocket extensions, you can remove the feature from the session with soup_session_remove_feature_by_type(), or disable it on individual requests with soup_message_disable_feature(). Looks up the stock HTTP description of @status_code. This is used by soup_message_set_status() to get the correct text to go with a given status code. <emphasis>There is no reason for you to ever use this function.</emphasis> If you wanted the textual description for the #SoupMessage:status_code of a given #SoupMessage, you should just look at the message's #SoupMessage:reason_phrase. However, you should only do that for use in debugging messages; HTTP reason phrases are not localized, and are not generally very descriptive anyway, and so they should never be presented to the user directly. Instead, you should create you own error messages based on the status code, and on what you were trying to do. the (terse, English) description of @status_code an HTTP status code Turns %SOUP_STATUS_CANT_RESOLVE into %SOUP_STATUS_CANT_RESOLVE_PROXY and %SOUP_STATUS_CANT_CONNECT into %SOUP_STATUS_CANT_CONNECT_PROXY. Other status codes are passed through unchanged. the "proxified" equivalent of @status_code. a status code Compares @v1 and @v2 in a case-insensitive manner %TRUE if they are equal (modulo case) an ASCII string another ASCII string Hashes @key in a case-insensitive manner. the hash code. ASCII string to hash Looks whether the @domain passed as argument is a public domain suffix (.org, .com, .co.uk, etc) or not. Prior to libsoup 2.46, this function required that @domain be in UTF-8 if it was an IDN. From 2.46 on, the name can be in either UTF-8 or ASCII format. %TRUE if it is a public domain, %FALSE otherwise. a domain name Finds the base domain for a given @hostname. The base domain is composed by the top level domain (such as .org, .com, .co.uk, etc) plus the second level domain, for example for myhost.mydomain.com it will return mydomain.com. Note that %NULL will be returned for private URLs (those not ending with any well known TLD) because choosing a base domain for them would be totally arbitrary. Prior to libsoup 2.46, this function required that @hostname be in UTF-8 if it was an IDN. From 2.46 on, the name can be in either UTF-8 or ASCII format (and the return value will be in the same format). a pointer to the start of the base domain in @hostname. If an error occurs, %NULL will be returned and @error set. a hostname Fully %<!-- -->-decodes @part. In the past, this would return %NULL if @part contained invalid percent-encoding, but now it just ignores the problem (as soup_uri_new() already did). the decoded URI part. a URI part This %<!-- -->-encodes the given URI part and returns the escaped version in allocated memory, which the caller must free when it is done. the encoded URI part a URI part additional reserved characters to escape (or %NULL) %<!-- -->-decodes any "unreserved" characters (or characters in @unescape_extra) in @part, and %<!-- -->-encodes any non-ASCII characters, spaces, and non-printing characters in @part. "Unreserved" characters are those that are not allowed to be used for punctuation according to the URI spec. For example, letters are unreserved, so soup_uri_normalize() will turn <literal>http://example.com/foo/b%<!-- -->61r</literal> into <literal>http://example.com/foo/bar</literal>, which is guaranteed to mean the same thing. However, "/" is "reserved", so <literal>http://example.com/foo%<!-- -->2Fbar</literal> would not be changed, because it might mean something different to the server. In the past, this would return %NULL if @part contained invalid percent-encoding, but now it just ignores the problem (as soup_uri_new() already did). the normalized URI part a URI part reserved characters to unescape (or %NULL) Appends the provided value of type @type to @array as with g_value_array_append(). (The provided data is copied rather than being inserted directly.) Use #GVariant API instead. a #GValueArray a #GType a value of type @type Appends the provided values into @array as with g_value_array_append(). (The provided data is copied rather than being inserted directly.) Use #GVariant API instead. a #GValueArray the type of the first value to add the first value to add, followed by other type/value pairs, terminated by %G_TYPE_INVALID Creates a #GValueArray from the provided arguments, which must consist of pairs of a #GType and a value of that type, terminated by %G_TYPE_INVALID. (The array will contain copies of the provided data rather than pointing to the passed-in data directly.) Use #GVariant API instead. a new #GValueArray, or %NULL if an error occurred. arguments to create a #GValueArray from Gets the @index_ element of @array and stores its value into the provided location. Use #GVariant API instead. %TRUE if @array contained a value with index @index_ and type @type, %FALSE if not. a #GValueArray the index to look up a #GType a value of type pointer-to-@type Inserts the provided value of type @type into @array as with g_value_array_insert(). (The provided data is copied rather than being inserted directly.) Use #GVariant API instead. a #GValueArray the index to insert at a #GType a value of type @type Creates a new %GValueArray. (This is just a wrapper around g_value_array_new(), for naming consistency purposes.) Use #GVariant API instead. a new %GValueArray Creates a new %GValueArray and copies the provided values into it. Use #GVariant API instead. a new %GValueArray the type of the first value to add the first value to add, followed by other type/value pairs, terminated by %G_TYPE_INVALID Extracts a #GValueArray into the provided arguments, which must consist of pairs of a #GType and a value of pointer-to-that-type, terminated by %G_TYPE_INVALID. The returned values will point to the same memory as the values in the array. Use #GVariant API instead. success or failure a #GValueArray arguments to extract @array into Inserts the provided value of type @type into @hash. (Unlike with g_hash_table_insert(), both the key and the value are copied). Use #GVariant API instead. a value hash the key a #GType a value of type @type Inserts the given data into @hash. As with soup_value_hash_insert(), the keys and values are copied rather than being inserted directly. Use #GVariant API instead. a value hash the key for the first value the type of @first_key, followed by the value, followed by additional key/type/value triplets, terminated by %NULL Inserts @value into @hash. (Unlike with g_hash_table_insert(), both the key and the value are copied). Use #GVariant API instead. a value hash the key a value Looks up @key in @hash and stores its value into the provided location. Use #GVariant API instead. %TRUE if @hash contained a value with key @key and type @type, %FALSE if not. a value hash the key to look up a #GType a value of type pointer-to-@type Looks up a number of keys in @hash and returns their values. Use #GVariant API instead. %TRUE if all of the keys were found, %FALSE if any were missing; note that you will generally need to initialize each destination variable to a reasonable default value, since there is no way to tell which keys were found and which were not. a value hash the first key to look up the type of @first_key, a pointer to that type, and then additional key/type/pointer triplets, terminated by %NULL. Creates a #GHashTable whose keys are strings and whose values are #GValue. Use #GVariant API instead. a new empty #GHashTable Creates a #GHashTable whose keys are strings and whose values are #GValue, and initializes it with the provided data. As with soup_value_hash_insert(), the keys and values are copied rather than being inserted directly. Use #GVariant API instead. a new #GHashTable, initialized with the given values the key for the first value the type of @first_key, followed by the value, followed by additional key/type/value triplets, terminated by %NULL Adds the necessary headers to @msg to request a WebSocket handshake. The message body and non-WebSocket-related headers are not modified. Use soup_websocket_client_prepare_handshake_with_extensions() if you want to include "Sec-WebSocket-Extensions" header in the request. This is a low-level function; if you use soup_session_websocket_connect_async() to create a WebSocket connection, it will call this for you. a #SoupMessage the "Origin" header to set list of protocols to offer Adds the necessary headers to @msg to request a WebSocket handshake including supported WebSocket extensions. The message body and non-WebSocket-related headers are not modified. This is a low-level function; if you use soup_session_websocket_connect_async() to create a WebSocket connection, it will call this for you. a #SoupMessage the "Origin" header to set list of protocols to offer list of supported extension types Looks at the response status code and headers in @msg and determines if they contain a valid WebSocket handshake response (given the handshake request in @msg's request headers). If the response contains the "Sec-WebSocket-Extensions" header, the handshake will be considered invalid. You need to use soup_websocket_client_verify_handshake_with_extensions() to handle responses with extensions. This is a low-level function; if you use soup_session_websocket_connect_async() to create a WebSocket connection, it will call this for you. %TRUE if @msg contains a completed valid WebSocket handshake, %FALSE and an error if not. #SoupMessage containing both client and server sides of a WebSocket handshake Looks at the response status code and headers in @msg and determines if they contain a valid WebSocket handshake response (given the handshake request in @msg's request headers). If @supported_extensions is non-%NULL, extensions included in the response "Sec-WebSocket-Extensions" are verified too. Accepted extensions are returned in @accepted_extensions parameter if non-%NULL. This is a low-level function; if you use soup_session_websocket_connect_async() to create a WebSocket connection, it will call this for you. %TRUE if @msg contains a completed valid WebSocket handshake, %FALSE and an error if not. #SoupMessage containing both client and server sides of a WebSocket handshake list of supported extension types a #GList of #SoupWebsocketExtension objects Examines the method and request headers in @msg and determines whether @msg contains a valid handshake request. If @origin is non-%NULL, then only requests containing a matching "Origin" header will be accepted. If @protocols is non-%NULL, then only requests containing a compatible "Sec-WebSocket-Protocols" header will be accepted. Requests containing "Sec-WebSocket-Extensions" header will be accepted even if the header is not valid. To check a request with extensions you need to use soup_websocket_server_check_handshake_with_extensions() and provide the list of supported extension types. Normally soup_websocket_server_process_handshake() will take care of this for you, and if you use soup_server_add_websocket_handler() to handle accepting WebSocket connections, it will call that for you. However, this function may be useful if you need to perform more complicated validation; eg, accepting multiple different Origins, or handling different protocols depending on the path. %TRUE if @msg contained a valid WebSocket handshake, %FALSE and an error if not. #SoupMessage containing the client side of a WebSocket handshake expected Origin header allowed WebSocket protocols. Examines the method and request headers in @msg and determines whether @msg contains a valid handshake request. If @origin is non-%NULL, then only requests containing a matching "Origin" header will be accepted. If @protocols is non-%NULL, then only requests containing a compatible "Sec-WebSocket-Protocols" header will be accepted. If @supported_extensions is non-%NULL, then only requests containing valid supported extensions in "Sec-WebSocket-Extensions" header will be accepted. Normally soup_websocket_server_process_handshake_with_extensioins() will take care of this for you, and if you use soup_server_add_websocket_handler() to handle accepting WebSocket connections, it will call that for you. However, this function may be useful if you need to perform more complicated validation; eg, accepting multiple different Origins, or handling different protocols depending on the path. %TRUE if @msg contained a valid WebSocket handshake, %FALSE and an error if not. #SoupMessage containing the client side of a WebSocket handshake expected Origin header allowed WebSocket protocols. list of supported extension types Examines the method and request headers in @msg and (assuming @msg contains a valid handshake request), fills in the handshake response. If @expected_origin is non-%NULL, then only requests containing a matching "Origin" header will be accepted. If @protocols is non-%NULL, then only requests containing a compatible "Sec-WebSocket-Protocols" header will be accepted. Requests containing "Sec-WebSocket-Extensions" header will be accepted even if the header is not valid. To process a request with extensions you need to use soup_websocket_server_process_handshake_with_extensions() and provide the list of supported extension types. This is a low-level function; if you use soup_server_add_websocket_handler() to handle accepting WebSocket connections, it will call this for you. %TRUE if @msg contained a valid WebSocket handshake request and was updated to contain a handshake response. %FALSE if not. #SoupMessage containing the client side of a WebSocket handshake expected Origin header allowed WebSocket protocols. Examines the method and request headers in @msg and (assuming @msg contains a valid handshake request), fills in the handshake response. If @expected_origin is non-%NULL, then only requests containing a matching "Origin" header will be accepted. If @protocols is non-%NULL, then only requests containing a compatible "Sec-WebSocket-Protocols" header will be accepted. If @supported_extensions is non-%NULL, then only requests containing valid supported extensions in "Sec-WebSocket-Extensions" header will be accepted. The accepted extensions will be returned in @accepted_extensions parameter if non-%NULL. This is a low-level function; if you use soup_server_add_websocket_handler() to handle accepting WebSocket connections, it will call this for you. %TRUE if @msg contained a valid WebSocket handshake request and was updated to contain a handshake response. %FALSE if not. #SoupMessage containing the client side of a WebSocket handshake expected Origin header allowed WebSocket protocols. list of supported extension types a #GList of #SoupWebsocketExtension objects This creates an XML-RPC fault response and returns it as a string. (To create a successful response, use soup_xmlrpc_build_method_response().) the text of the fault the fault code a printf()-style format string the parameters to @fault_format This creates an XML-RPC methodCall and returns it as a string. This is the low-level method that soup_xmlrpc_request_new() is built on. @params is an array of #GValue representing the parameters to @method. (It is *not* a #GValueArray, although if you have a #GValueArray, you can just pass its <literal>values</literal>f and <literal>n_values</literal> fields.) The correspondence between glib types and XML-RPC types is: int: #int (%G_TYPE_INT) boolean: #gboolean (%G_TYPE_BOOLEAN) string: #char* (%G_TYPE_STRING) double: #double (%G_TYPE_DOUBLE) datetime.iso8601: #SoupDate (%SOUP_TYPE_DATE) base64: #GByteArray (%SOUP_TYPE_BYTE_ARRAY) struct: #GHashTable (%G_TYPE_HASH_TABLE) array: #GValueArray (%G_TYPE_VALUE_ARRAY) For structs, use a #GHashTable that maps strings to #GValue; soup_value_hash_new() and related methods can help with this. Use soup_xmlrpc_build_request() instead. the text of the methodCall, or %NULL on error the name of the XML-RPC method arguments to @method length of @params This creates a (successful) XML-RPC methodResponse and returns it as a string. To create a fault response, use soup_xmlrpc_build_fault(). The glib type to XML-RPC type mapping is as with soup_xmlrpc_build_method_call(), qv. Use soup_xmlrpc_build_response() instead. the text of the methodResponse, or %NULL on error the return value This creates an XML-RPC methodCall and returns it as a string. This is the low-level method that soup_xmlrpc_message_new() is built on. @params is a #GVariant tuple representing the method parameters. Serialization details: - "a{s*}" and "{s*}" are serialized as &lt;struct&gt; - "ay" is serialized as &lt;base64&gt; - Other arrays and tuples are serialized as &lt;array&gt; - booleans are serialized as &lt;boolean&gt; - byte, int16, uint16 and int32 are serialized as &lt;int&gt; - uint32 and int64 are serialized as the nonstandard &lt;i8&gt; type - doubles are serialized as &lt;double&gt; - Strings are serialized as &lt;string&gt; - Variants (i.e. "v" type) are unwrapped and their child is serialized. - #GVariants created by soup_xmlrpc_variant_new_datetime() are serialized as &lt;dateTime.iso8601&gt; - Other types are not supported and will return %NULL and set @error. This notably includes: object-paths, signatures, uint64, handles, maybes and dictionaries with non-string keys. If @params is floating, it is consumed. the text of the methodCall, or %NULL on error. the name of the XML-RPC method a #GVariant tuple This creates a (successful) XML-RPC methodResponse and returns it as a string. To create a fault response, use soup_xmlrpc_build_fault(). This is the low-level method that soup_xmlrpc_message_set_response() is built on. See soup_xmlrpc_build_request() for serialization details, but note that since a method can only have a single return value, @value should not be a tuple here (unless the return value is an array). If @value is floating, it is consumed. the text of the methodResponse, or %NULL on error. the return value Parses @method_call to get the name and parameters, and puts the parameters into variables of the appropriate types. The parameters are handled similarly to @soup_xmlrpc_build_method_call, with pairs of types and values, terminated by %G_TYPE_INVALID, except that values are pointers to variables of the indicated type, rather than values of the type. See also soup_xmlrpc_parse_method_call(), which can be used if you don't know the types of the parameters. Use soup_xmlrpc_parse_request_full() instead. success or failure. the XML-RPC methodCall string the length of @method_call, or -1 if it is NUL-terminated on return, the methodName from @method_call return types and locations for parameters Parses @method_response and extracts the return value into a variable of the correct type. If @method_response is a fault, the return value will be unset, and @error will be set to an error of type %SOUP_XMLRPC_FAULT, with the error #code containing the fault code, and the error #message containing the fault string. (If @method_response cannot be parsed at all, soup_xmlrpc_extract_method_response() will return %FALSE, but @error will be unset.) Use soup_xmlrpc_parse_response() instead. %TRUE if a return value was parsed, %FALSE if the response was of the wrong type, or contained a fault. the XML-RPC methodResponse string the length of @method_response, or -1 if it is NUL-terminated error return value the expected type of the return value location for return value Creates an XML-RPC methodCall and returns a #SoupMessage, ready to send, for that method call. See soup_xmlrpc_build_request() for serialization details. If @params is floating, it is consumed. a #SoupMessage encoding the indicated XML-RPC request, or %NULL on error. URI of the XML-RPC service the name of the XML-RPC method to invoke at @uri a #GVariant tuple Sets the status code and response body of @msg to indicate an unsuccessful XML-RPC call, with the error described by @fault_code and @fault_format. an XML-RPC request the fault code a printf()-style format string the parameters to @fault_format Sets the status code and response body of @msg to indicate a successful XML-RPC call, with a return value given by @value. To set a fault response, use soup_xmlrpc_message_set_fault(). See soup_xmlrpc_build_request() for serialization details. If @value is floating, it is consumed. %TRUE on success, %FALSE otherwise. an XML-RPC request a #GVariant Parses @method_call to get the name and parameters, and returns the parameter values in a #GValueArray; see also soup_xmlrpc_extract_method_call(), which is more convenient if you know in advance what the types of the parameters will be. Use soup_xmlrpc_parse_request_full() instead. success or failure. the XML-RPC methodCall string the length of @method_call, or -1 if it is NUL-terminated on return, the methodName from @method_call on return, the parameters from @method_call Parses @method_response and returns the return value in @value. If @method_response is a fault, @value will be unchanged, and @error will be set to an error of type %SOUP_XMLRPC_FAULT, with the error #code containing the fault code, and the error #message containing the fault string. (If @method_response cannot be parsed at all, soup_xmlrpc_parse_method_response() will return %FALSE, but @error will be unset.) Use soup_xmlrpc_parse_response() instead. %TRUE if a return value was parsed, %FALSE if the response could not be parsed, or contained a fault. the XML-RPC methodResponse string the length of @method_response, or -1 if it is NUL-terminated on return, the return value from @method_call Parses @method_call and return the method name. Method parameters can be parsed later using soup_xmlrpc_params_parse(). method's name, or %NULL on error. the XML-RPC methodCall string the length of @method_call, or -1 if it is NUL-terminated on success, a new #SoupXMLRPCParams Parses @method_response and returns the return value. If @method_response is a fault, %NULL is returned, and @error will be set to an error in the %SOUP_XMLRPC_FAULT domain, with the error code containing the fault code, and the error message containing the fault string. If @method_response cannot be parsed, %NULL is returned, and @error will be set to an error in the %SOUP_XMLRPC_ERROR domain. See soup_xmlrpc_params_parse() for deserialization details. a new (non-floating) #GVariant, or %NULL the XML-RPC methodResponse string the length of @method_response, or -1 if it is NUL-terminated A valid #GVariant type string, or %NULL Creates an XML-RPC methodCall and returns a #SoupMessage, ready to send, for that method call. The parameters are passed as type/value pairs; ie, first a #GType, and then a value of the appropriate type, finally terminated by %G_TYPE_INVALID. Use soup_xmlrpc_message_new() instead. a #SoupMessage encoding the indicated XML-RPC request. URI of the XML-RPC service the name of the XML-RPC method to invoke at @uri parameters for @method Sets the status code and response body of @msg to indicate an unsuccessful XML-RPC call, with the error described by @fault_code and @fault_format. Use soup_xmlrpc_message_set_fault() instead. an XML-RPC request the fault code a printf()-style format string the parameters to @fault_format Sets the status code and response body of @msg to indicate a successful XML-RPC call, with a return value given by @type and the following varargs argument, of the type indicated by @type. Use soup_xmlrpc_message_set_response() instead. an XML-RPC request the type of the response value the response value Get the #SoupDate from special #GVariant created by soup_xmlrpc_variant_new_datetime() or by parsing a &lt;dateTime.iso8601&gt; node. See soup_xmlrpc_params_parse(). If @variant does not contain a datetime it will return an error but it is not considered a programmer error because it generally means parameters received are not in the expected type. a new #SoupDate, or %NULL on error. a #GVariant Construct a special #GVariant used to serialize a &lt;dateTime.iso8601&gt; node. See soup_xmlrpc_build_request(). The actual type of the returned #GVariant is unspecified and "v" or "*" should be used in variant format strings. For example: <informalexample><programlisting> args = g_variant_new ("(v)", soup_xmlrpc_variant_new_datetime (date)); </programlisting></informalexample> a floating #GVariant. a #SoupDate