pidgin/pidgin

facebook: Make $.hugePictureUrl.uri optional

2016-10-22, dequis
69b44723d52c
facebook: Make $.hugePictureUrl.uri optional

Facebook seems to randomly send null in this field sometimes. It's not
very important so it can be made optional.

This includes moving the checksum code (which was previously duplicated)
to a separate function so that there's a single null check.
/* 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.
*
* 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.
*
* 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:
* @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_ */