diff options
Diffstat (limited to 'pidgin/libpurple/http.h')
| -rw-r--r-- | pidgin/libpurple/http.h | 964 |
1 files changed, 964 insertions, 0 deletions
diff --git a/pidgin/libpurple/http.h b/pidgin/libpurple/http.h new file mode 100644 index 0000000..870d766 --- /dev/null +++ b/pidgin/libpurple/http.h @@ -0,0 +1,964 @@ +/* purple + * + * Purple is the legal property of its developers, whose names are too numerous + * to list here. Please refer to the COPYRIGHT file distributed with this + * source distribution. + * + * This program is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02111-1301 USA + */ + +#ifndef _PURPLE_HTTP_H_ +#define _PURPLE_HTTP_H_ +/** + * SECTION:http + * @section_id: libpurple-http + * @short_description: <filename>http.h</filename> + * @title: HTTP API + */ + +#include <glib.h> + +#include "connection.h" + +/** + * PurpleHttpRequest: + * + * A structure containing all data required to generate a single HTTP request. + */ +typedef struct _PurpleHttpRequest PurpleHttpRequest; + +/** + * PurpleHttpConnection: + * + * A representation of actually running HTTP request. Can be used to cancel the + * request. + */ +typedef struct _PurpleHttpConnection PurpleHttpConnection; + +/** + * PurpleHttpResponse: + * + * All information got with response for HTTP request. + */ +typedef struct _PurpleHttpResponse PurpleHttpResponse; + +/** + * PurpleHttpURL: + * + * Parsed representation for the URL. + */ +typedef struct _PurpleHttpURL PurpleHttpURL; + +/** + * PurpleHttpCookieJar: + * + * An collection of cookies, got from HTTP response or provided for HTTP + * request. + */ +typedef struct _PurpleHttpCookieJar PurpleHttpCookieJar; + +/** + * PurpleHttpKeepalivePool: + * + * A pool of TCP connections for HTTP Keep-Alive session. + */ +typedef struct _PurpleHttpKeepalivePool PurpleHttpKeepalivePool; + +/** + * PurpleHttpConnectionSet: + * + * A set of running HTTP requests. Can be used to cancel all of them at once. + */ +typedef struct _PurpleHttpConnectionSet PurpleHttpConnectionSet; + +/** + * PurpleHttpCallback: + * + * An callback called after performing (successfully or not) HTTP request. + */ +typedef void (*PurpleHttpCallback)(PurpleHttpConnection *http_conn, + PurpleHttpResponse *response, gpointer user_data); + +/** + * PurpleHttpContentReaderCb: + * + * An callback called after storing data requested by PurpleHttpContentReader. + */ +typedef void (*PurpleHttpContentReaderCb)(PurpleHttpConnection *http_conn, + gboolean success, gboolean eof, size_t stored); + +/** + * PurpleHttpContentReader: + * @http_conn: Connection, which requests data. + * @buffer: Buffer to store data to (with offset ignored). + * @offset: Position, from where to read data. + * @length: Length of data to read. + * @user_data: The user data passed with callback function. + * @cb: The function to call after storing data to buffer. + * + * An callback for getting large request contents (ie. from file stored on + * disk). + */ +typedef void (*PurpleHttpContentReader)(PurpleHttpConnection *http_conn, + gchar *buffer, size_t offset, size_t length, gpointer user_data, + PurpleHttpContentReaderCb cb); + +/** + * PurpleHttpContentWriter: + * @http_conn: Connection, which requests data. + * @response: Response at point got so far (may change later). + * @buffer: Buffer to read data from (with offset ignored). + * @offset: Position of data got (its value is offset + length of + * previous call), can be safely ignored. + * @length: Length of data read. + * @user_data: The user data passed with callback function. + * + * An callback for writting large response contents. + * + * Returns: TRUE, if succeeded, FALSE otherwise. + */ +typedef gboolean (*PurpleHttpContentWriter)(PurpleHttpConnection *http_conn, + PurpleHttpResponse *response, const gchar *buffer, size_t offset, + size_t length, gpointer user_data); + +/** + * PurpleHttpProgressWatcher: + * @http_conn: The HTTP Connection. + * @reading_state: FALSE, is we are sending the request, TRUE, when reading + * the response. + * @processed: The amount of data already processed. + * @total: Total amount of data (in current state). + * @user_data: The user data passed with callback function. + * + * An callback for watching HTTP connection progress. + */ +typedef void (*PurpleHttpProgressWatcher)(PurpleHttpConnection *http_conn, + gboolean reading_state, int processed, int total, gpointer user_data); + +G_BEGIN_DECLS + +/**************************************************************************/ +/* Performing HTTP requests */ +/**************************************************************************/ + +/** + * purple_http_get: + * @gc: The connection for which the request is needed, or NULL. + * @callback: (scope call): The callback function. + * @user_data: The user data to pass to the callback function. + * @url: The URL. + * + * Fetches the data from a URL with GET request, and passes it to a callback + * function. + * + * Returns: The HTTP connection struct. + */ +PurpleHttpConnection * purple_http_get(PurpleConnection *gc, + PurpleHttpCallback callback, gpointer user_data, const gchar *url); + +/** + * purple_http_get_printf: + * @gc: The connection for which the request is needed, or NULL. + * @callback: (scope call): The callback function. + * @user_data: The user data to pass to the callback function. + * @format: The format string. + * @...: The parameters to insert into the format string. + * + * Constructs an URL and fetches the data from it with GET request, then passes + * it to a callback function. + * + * Returns: The HTTP connection struct. + */ +PurpleHttpConnection * purple_http_get_printf(PurpleConnection *gc, + PurpleHttpCallback callback, gpointer user_data, + const gchar *format, ...) G_GNUC_PRINTF(4, 5); + +/** + * purple_http_request: + * @gc: The connection for which the request is needed, or NULL. + * @request: The request. + * @callback: (scope call): The callback function. + * @user_data: The user data to pass to the callback function. + * + * Fetches a HTTP request and passes the response to a callback function. + * Provided request struct can be shared by multiple http requests but can not + * be modified when any of these is running. + * + * Returns: The HTTP connection struct. + */ +PurpleHttpConnection * purple_http_request(PurpleConnection *gc, + PurpleHttpRequest *request, PurpleHttpCallback callback, + gpointer user_data); + +/**************************************************************************/ +/* HTTP connection API */ +/**************************************************************************/ + +/** + * purple_http_conn_cancel: + * @http_conn: The data returned when you initiated the HTTP request. + * + * Cancel a pending HTTP request. + */ +void purple_http_conn_cancel(PurpleHttpConnection *http_conn); + +/** + * purple_http_conn_cancel_all: + * @gc: The handle. + * + * Cancels all HTTP connections associated with the specified handle. + */ +void purple_http_conn_cancel_all(PurpleConnection *gc); + +/** + * purple_http_conn_is_running: + * @http_conn: The HTTP connection (may be invalid pointer). + * + * Checks, if provided HTTP request is running. + * + * Returns: TRUE, if provided connection is currently running. + */ +gboolean purple_http_conn_is_running(PurpleHttpConnection *http_conn); + +/** + * purple_http_conn_get_request: + * @http_conn: The HTTP connection. + * + * Gets PurpleHttpRequest used for specified HTTP connection. + * + * Returns: The PurpleHttpRequest object. + */ +PurpleHttpRequest * purple_http_conn_get_request( + PurpleHttpConnection *http_conn); + +/** + * purple_http_conn_get_cookie_jar: + * @http_conn: The HTTP connection. + * + * Gets cookie jar used within connection. + * + * Returns: The cookie jar. + */ +PurpleHttpCookieJar * purple_http_conn_get_cookie_jar( + PurpleHttpConnection *http_conn); + +/** + * purple_http_conn_get_purple_connection: + * @http_conn: The HTTP connection. + * + * Gets PurpleConnection tied with specified HTTP connection. + * + * Returns: The PurpleConnection object. + */ +PurpleConnection * purple_http_conn_get_purple_connection( + PurpleHttpConnection *http_conn); + +/** + * purple_http_conn_set_progress_watcher: + * @http_conn: The HTTP connection. + * @watcher: (scope call): The watcher. + * @user_data: The user data to pass to the callback function. + * @interval_threshold: Minimum interval (in microseconds) of calls to + * watcher, or -1 for default. + * + * Sets the watcher, called after writing or reading data to/from HTTP stream. + * May be used for updating transfer progress gauge. + */ +void purple_http_conn_set_progress_watcher(PurpleHttpConnection *http_conn, + PurpleHttpProgressWatcher watcher, gpointer user_data, + gint interval_threshold); + + +/**************************************************************************/ +/* URL processing API */ +/**************************************************************************/ + +/** + * purple_http_url_parse: + * @url: The URL to parse. + * + * Parses a URL. + * + * The returned data must be freed with purple_http_url_free. + * + * Returns: The parsed url or NULL, if the URL is invalid. + */ +PurpleHttpURL * +purple_http_url_parse(const char *url); + +/** + * purple_http_url_free: + * @parsed_url: The parsed URL struct, or NULL. + * + * Frees the parsed URL struct. + */ +void +purple_http_url_free(PurpleHttpURL *parsed_url); + +/** + * purple_http_url_relative: + * @base_url: The base URL. The result is stored here. + * @relative_url: The relative URL. + * + * Converts the base URL to the absolute form of the provided relative URL. + * + * Example: "https://example.com/path/to/file.html" + "subdir/other-file.html" = + * "https://example.com/path/to/subdir/another-file.html" + */ +void +purple_http_url_relative(PurpleHttpURL *base_url, PurpleHttpURL *relative_url); + +/** + * purple_http_url_print: + * @parsed_url: The URL struct. + * + * Converts the URL struct to the printable form. The result may not be a valid + * URL (in cases, when the struct doesn't have all fields filled properly). + * + * The result must be g_free'd. + * + * Returns: The printable form of the URL. + */ +gchar * +purple_http_url_print(PurpleHttpURL *parsed_url); + +/** + * purple_http_url_get_protocol: + * @parsed_url: The URL struct. + * + * Gets the protocol part of URL. + * + * Returns: The protocol. + */ +const gchar * +purple_http_url_get_protocol(const PurpleHttpURL *parsed_url); + +/** + * purple_http_url_get_username: + * @parsed_url: The URL struct. + * + * Gets the username part of URL. + * + * Returns: The username. + */ +const gchar * +purple_http_url_get_username(const PurpleHttpURL *parsed_url); + +/** + * purple_http_url_get_password: + * @parsed_url: The URL struct. + * + * Gets the password part of URL. + * + * Returns: The password. + */ +const gchar * +purple_http_url_get_password(const PurpleHttpURL *parsed_url); + +/** + * purple_http_url_get_host: + * @parsed_url: The URL struct. + * + * Gets the hostname part of URL. + * + * Returns: The hostname. + */ +const gchar * +purple_http_url_get_host(const PurpleHttpURL *parsed_url); + +/** + * purple_http_url_get_port: + * @parsed_url: The URL struct. + * + * Gets the port part of URL. + * + * Returns: The port number. + */ +int +purple_http_url_get_port(const PurpleHttpURL *parsed_url); + +/** + * purple_http_url_get_path: + * @parsed_url: The URL struct. + * + * Gets the path part of URL. + * + * Returns: The path. + */ +const gchar * +purple_http_url_get_path(const PurpleHttpURL *parsed_url); + +/** + * purple_http_url_get_fragment: + * @parsed_url: The URL struct. + * + * Gets the fragment part of URL. + * + * Returns: The fragment. + */ +const gchar * +purple_http_url_get_fragment(const PurpleHttpURL *parsed_url); + + +/**************************************************************************/ +/* Cookie jar API */ +/**************************************************************************/ + +/** + * purple_http_cookie_jar_new: + * + * Creates new cookie jar, + * + * Returns: empty cookie jar. + */ +PurpleHttpCookieJar * purple_http_cookie_jar_new(void); + +/** + * purple_http_cookie_jar_ref: + * @cookie_jar: The cookie jar. + * + * Increment the reference count. + */ +void purple_http_cookie_jar_ref(PurpleHttpCookieJar *cookie_jar); + +/** + * purple_http_cookie_jar_unref: + * @cookie_jar: The cookie jar. + * + * Decrement the reference count. + * + * If the reference count reaches zero, the cookie jar will be freed. + * + * Returns: @cookie_jar or %NULL if the reference count reached zero. + */ +PurpleHttpCookieJar * purple_http_cookie_jar_unref( + PurpleHttpCookieJar *cookie_jar); + +/** + * purple_http_cookie_jar_set: + * @cookie_jar: The cookie jar. + * @name: Cookie name. + * @value: Cookie contents. + * + * Sets the cookie. + */ +void purple_http_cookie_jar_set(PurpleHttpCookieJar *cookie_jar, + const gchar *name, const gchar *value); + +/** + * purple_http_cookie_jar_get: + * @cookie_jar: The cookie jar. + * @name: Cookie name. + * + * Gets the cookie. + * + * The result must be g_free'd. + * + * Returns: Cookie contents, or NULL, if cookie doesn't exists. + */ +gchar * purple_http_cookie_jar_get(PurpleHttpCookieJar *cookie_jar, + const gchar *name); + +/** + * purple_http_cookie_jar_is_empty: + * @cookie_jar: The cookie jar. + * + * Checks, if the cookie jar contains any cookies. + * + * Returns: TRUE, if cookie jar contains any cookie, FALSE otherwise. + */ +gboolean purple_http_cookie_jar_is_empty(PurpleHttpCookieJar *cookie_jar); + + +/**************************************************************************/ +/* HTTP Request API */ +/**************************************************************************/ + +/** + * purple_http_request_new: + * @url: The URL to request for, or NULL to leave empty (to be set with + * purple_http_request_set_url). + * + * Creates the new instance of HTTP request configuration. + * + * Returns: The new instance of HTTP request struct. + */ +PurpleHttpRequest * purple_http_request_new(const gchar *url); + +/** + * purple_http_request_ref: + * @request: The request. + * + * Increment the reference count. + */ +void purple_http_request_ref(PurpleHttpRequest *request); + +/** + * purple_http_request_unref: + * @request: The request. + * + * Decrement the reference count. + * + * If the reference count reaches zero, the http request struct will be freed. + * + * Returns: @request or %NULL if the reference count reached zero. + */ +PurpleHttpRequest * purple_http_request_unref(PurpleHttpRequest *request); + +/** + * purple_http_request_set_url: + * @request: The request. + * @url: The url. + * + * Sets URL for HTTP request. + */ +void purple_http_request_set_url(PurpleHttpRequest *request, const gchar *url); + +/** + * purple_http_request_set_url_printf: + * @request: The request. + * @format: The format string. + * @...: The parameters to insert into the format string. + * + * Constructs and sets an URL for HTTP request. + */ +void purple_http_request_set_url_printf(PurpleHttpRequest *request, + const gchar *format, ...) G_GNUC_PRINTF(2, 3); + +/** + * purple_http_request_get_url: + * @request: The request. + * + * Gets URL set for the HTTP request. + * + * Returns: URL set for this request. + */ +const gchar * purple_http_request_get_url(PurpleHttpRequest *request); + +/** + * purple_http_request_set_method: + * @request: The request. + * @method: The method, or NULL for default. + * + * Sets custom HTTP method used for the request. + */ +void purple_http_request_set_method(PurpleHttpRequest *request, + const gchar *method); + +/** + * purple_http_request_get_method: + * @request: The request. + * + * Gets HTTP method set for the request. + * + * Returns: The method. + */ +const gchar * purple_http_request_get_method(PurpleHttpRequest *request); + +/** + * purple_http_request_set_keepalive_pool: + * @request: The request. + * @pool: The new KeepAlive pool, or NULL to reset. + * + * Sets HTTP KeepAlive connections pool for the request. + * + * It increases pool's reference count. + */ +void +purple_http_request_set_keepalive_pool(PurpleHttpRequest *request, + PurpleHttpKeepalivePool *pool); + +/** + * purple_http_request_get_keepalive_pool: + * @request: The request. + * + * Gets HTTP KeepAlive connections pool associated with the request. + * + * It doesn't affect pool's reference count. + * + * Returns: The KeepAlive pool, used for the request. + */ +PurpleHttpKeepalivePool * +purple_http_request_get_keepalive_pool(PurpleHttpRequest *request); + +/** + * purple_http_request_set_contents: + * @request: The request. + * @contents: The contents. + * @length: The length of contents (-1 if it's a NULL-terminated string) + * + * Sets contents of HTTP request (for example, POST data). + */ +void purple_http_request_set_contents(PurpleHttpRequest *request, + const gchar *contents, int length); + +/** + * purple_http_request_set_contents_reader: + * @request: The request. + * @reader: (scope call): The reader callback. + * @contents_length: The size of all contents. + * @user_data: The user data to pass to the callback function. + * + * Sets contents reader for HTTP request, used mainly for possible large + * uploads. + */ +void purple_http_request_set_contents_reader(PurpleHttpRequest *request, + PurpleHttpContentReader reader, int contents_length, gpointer user_data); + +/** + * purple_http_request_set_response_writer: + * @request: The request. + * @writer: (scope call): The writer callback, or %NULL to remove existing. + * @user_data: The user data to pass to the callback function. + * + * Set contents writer for HTTP response. + */ +void purple_http_request_set_response_writer(PurpleHttpRequest *request, + PurpleHttpContentWriter writer, gpointer user_data); + +/** + * purple_http_request_set_timeout: + * @request: The request. + * @timeout: Time (in seconds) after that timeout will be cancelled, + * -1 for infinite time. + * + * Set maximum amount of time, that request is allowed to run. + */ +void purple_http_request_set_timeout(PurpleHttpRequest *request, int timeout); + +/** + * purple_http_request_get_timeout: + * @request: The request. + * + * Get maximum amount of time, that request is allowed to run. + * + * Returns: Timeout currently set (-1 for infinite). + */ +int purple_http_request_get_timeout(PurpleHttpRequest *request); + +/** + * purple_http_request_set_max_redirects: + * @request: The request. + * @max_redirects: Maximum amount of redirects, or -1 for unlimited. + * + * Sets maximum amount of redirects. + */ +void purple_http_request_set_max_redirects(PurpleHttpRequest *request, + int max_redirects); + +/** + * purple_http_request_get_max_redirects: + * @request: The request. + * + * Gets maximum amount of redirects. + * + * Returns: Current maximum amount of redirects (-1 for unlimited). + */ +int purple_http_request_get_max_redirects(PurpleHttpRequest *request); + +/** + * purple_http_request_set_cookie_jar: + * @request: The request. + * @cookie_jar: The cookie jar. + * + * Sets cookie jar used for the request. + */ +void purple_http_request_set_cookie_jar(PurpleHttpRequest *request, + PurpleHttpCookieJar *cookie_jar); + +/** + * purple_http_request_get_cookie_jar: + * @request: The request. + * + * Gets cookie jar used for the request. + * + * Returns: The cookie jar. + */ +PurpleHttpCookieJar * purple_http_request_get_cookie_jar( + PurpleHttpRequest *request); + +/** + * purple_http_request_set_http11: + * @request: The request. + * @http11: TRUE for HTTP/1.1, FALSE for HTTP/1.0. + * + * Sets HTTP version to use. + */ +void purple_http_request_set_http11(PurpleHttpRequest *request, + gboolean http11); + +/** + * purple_http_request_is_http11: + * @request: The request. + * + * Gets used HTTP version. + * + * Returns: TRUE, if we use HTTP/1.1, FALSE for HTTP/1.0. + */ +gboolean purple_http_request_is_http11(PurpleHttpRequest *request); + +/** + * purple_http_request_set_max_len: + * @request: The request. + * @max_len: Maximum length of response to read (-1 for the maximum + * supported amount). + * + * Sets maximum length of response content to read. + * + * Headers length doesn't count here. + * + */ +void purple_http_request_set_max_len(PurpleHttpRequest *request, int max_len); + +/** + * purple_http_request_get_max_len: + * @request: The request. + * + * Gets maximum length of response content to read. + * + * Returns: Maximum length of response to read, or -1 if unlimited. + */ +int purple_http_request_get_max_len(PurpleHttpRequest *request); + +/** + * purple_http_request_header_set: + * @request: The request. + * @key: A header to be set. + * @value: A value to set, or NULL to remove specified header. + * + * Sets (replaces, if exists) specified HTTP request header with provided value. + * + * See purple_http_request_header_add(). + */ +void purple_http_request_header_set(PurpleHttpRequest *request, + const gchar *key, const gchar *value); + +/** + * purple_http_request_header_set_printf: + * @request: The request. + * @key: A header to be set. + * @format: The format string. + * + * Constructs and sets (replaces, if exists) specified HTTP request header. + */ +void purple_http_request_header_set_printf(PurpleHttpRequest *request, + const gchar *key, const gchar *format, ...) G_GNUC_PRINTF(3, 4); + +/** + * purple_http_request_header_add: + * @request: The request. + * @key: A header to be set. + * @value: A value to set. + * + * Adds (without replacing, if exists) an HTTP request header. + * + * See purple_http_request_header_set(). + */ +void purple_http_request_header_add(PurpleHttpRequest *request, + const gchar *key, const gchar *value); + + +/**************************************************************************/ +/* HTTP Keep-Alive pool API */ +/**************************************************************************/ + +/** + * purple_http_keepalive_pool_new: + * + * Creates a new HTTP Keep-Alive pool. + */ +PurpleHttpKeepalivePool * +purple_http_keepalive_pool_new(void); + +/** + * purple_http_keepalive_pool_ref: + * @pool: The HTTP Keep-Alive pool. + * + * Increment the reference count. + */ +void +purple_http_keepalive_pool_ref(PurpleHttpKeepalivePool *pool); + +/** + * purple_http_keepalive_pool_unref: + * @pool: The HTTP Keep-Alive pool. + * + * Decrement the reference count. + * + * If the reference count reaches zero, the pool will be freed and all + * connections will be closed. + * + * Returns: @pool or %NULL if the reference count reached zero. + */ +PurpleHttpKeepalivePool * +purple_http_keepalive_pool_unref(PurpleHttpKeepalivePool *pool); + +/** + * purple_http_keepalive_pool_set_limit_per_host: + * @pool: The HTTP Keep-Alive pool. + * @limit: The new limit, 0 for unlimited. + * + * Sets maximum allowed number of connections to specific host-triple (is_ssl + + * hostname + port). + */ +void +purple_http_keepalive_pool_set_limit_per_host(PurpleHttpKeepalivePool *pool, + guint limit); + +/** + * purple_http_keepalive_pool_get_limit_per_host: + * @pool: The HTTP Keep-Alive pool. + * + * Gets maximum allowed number of connections to specific host-triple (is_ssl + + * hostname + port). + * + * Returns: The limit. + */ +guint +purple_http_keepalive_pool_get_limit_per_host(PurpleHttpKeepalivePool *pool); + + +/**************************************************************************/ +/* HTTP connection set API */ +/**************************************************************************/ + +PurpleHttpConnectionSet * +purple_http_connection_set_new(void); + +void +purple_http_connection_set_destroy(PurpleHttpConnectionSet *set); + +void +purple_http_connection_set_add(PurpleHttpConnectionSet *set, + PurpleHttpConnection *http_conn); + + +/**************************************************************************/ +/* HTTP response API */ +/**************************************************************************/ + +/** + * purple_http_response_is_successful: + * @response: The response. + * + * Checks, if HTTP request was performed successfully. + * + * Returns: TRUE, if request was performed successfully. + */ +gboolean purple_http_response_is_successful(PurpleHttpResponse *response); + +/** + * purple_http_response_get_code: + * @response: The response. + * + * Gets HTTP response code. + * + * Returns: HTTP response code. + */ +int purple_http_response_get_code(PurpleHttpResponse *response); + +/** + * purple_http_response_get_error: + * @response: The response. + * + * Gets error description. + * + * Returns: Localized error description or NULL, if there was no error. + */ +const gchar * purple_http_response_get_error(PurpleHttpResponse *response); + +/** + * purple_http_response_get_data_len: + * @response: The response. + * + * Gets HTTP response data length. + * + * Returns: Data length; + */ +gsize purple_http_response_get_data_len(PurpleHttpResponse *response); + +/** + * purple_http_response_get_data: + * @response: The response. + * @len: Return address for the size of the data. Can be NULL. + * + * Gets HTTP response data. + * + * Response data is not written, if writer callback was set for request. + * + * Returns: The data. + */ +const gchar * purple_http_response_get_data(PurpleHttpResponse *response, size_t *len); + +/** + * purple_http_response_get_all_headers: + * @response: The response. + * + * Gets all headers got with response. + * + * Returns: GList of PurpleKeyValuePair, which keys are header field + * names (gchar*) and values are its contents (gchar*). + */ +const GList * purple_http_response_get_all_headers(PurpleHttpResponse *response); + +/** + * purple_http_response_get_headers_by_name: + * @response: The response. + * @name: The name of header field. + * + * Gets all headers with specified name got with response. + * + * Returns: GList of header field records contents (gchar*). + */ +const GList * purple_http_response_get_headers_by_name( + PurpleHttpResponse *response, const gchar *name); + +/** + * purple_http_response_get_header: + * @response: The response. + * @name: The name of header field. + * + * Gets one header contents with specified name got with response. + * + * To get all headers with the same name, use + * purple_http_response_get_headers_by_name instead. + * + * Returns: Header field contents or NULL, if there is no such one. + */ +const gchar * purple_http_response_get_header(PurpleHttpResponse *response, + const gchar *name); + + +/**************************************************************************/ +/* HTTP Subsystem */ +/**************************************************************************/ + +/** + * purple_http_init: + * + * Initializes the http subsystem. + */ +void purple_http_init(void); + +/** + * purple_http_uninit: + * + * Uninitializes the http subsystem. + */ +void purple_http_uninit(void); + +G_END_DECLS + +#endif /* _PURPLE_HTTP_H_ */ |