SoupDate

typedef struct {
	int      year;
	int      month;
	int      day;

	int      hour;
	int      minute;
	int      second;

	gboolean utc;
	int      offset;
} SoupDate;

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.

enum SoupDateFormat

typedef enum {
	SOUP_DATE_HTTP = 1,
	SOUP_DATE_COOKIE,
	SOUP_DATE_RFC2822,
	SOUP_DATE_ISO8601_COMPACT,
	SOUP_DATE_ISO8601_FULL,
	SOUP_DATE_ISO8601 = SOUP_DATE_ISO8601_FULL,
	SOUP_DATE_ISO8601_XMLRPC
} SoupDateFormat;

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.

soup_date_new ()

SoupDate*           soup_date_new                       (int year,
                                                         int month,
                                                         int day,
                                                         int hour,
                                                         int minute,
                                                         int second);

Creates a SoupDate representing the indicated time, UTC.

soup_date_new_from_string ()

SoupDate*           soup_date_new_from_string           (const char *date_string);

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.)

soup_date_new_from_time_t ()

SoupDate*           soup_date_new_from_time_t           (time_t when);

Creates a SoupDate corresponding to when

soup_date_new_from_now ()

SoupDate*           soup_date_new_from_now              (int offset_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.

soup_date_to_string ()

char*               soup_date_to_string                 (SoupDate *date,
                                                         SoupDateFormat format);

Converts date to a string in the format described by format.

soup_date_to_time_t ()

time_t              soup_date_to_time_t                 (SoupDate *date);

Converts date to a time_t.

If date is not representable as a time_t, it will be clamped into range. (In particular, some HTTP cookies have expiration dates after "Y2.038k" (2038-01-19T03:14:07Z).)

soup_date_to_timeval ()

void                soup_date_to_timeval                (SoupDate *date,
                                                         GTimeVal *time);

Converts date to a GTimeVal.

Since 2.24

soup_date_is_past ()

gboolean            soup_date_is_past                   (SoupDate *date);

Determines if date is in the past.

Since 2.24

soup_date_free ()

void                soup_date_free                      (SoupDate *date);

Frees date.

soup_headers_parse_request ()

guint               soup_headers_parse_request          (const char *str,
                                                         int len,
                                                         SoupMessageHeaders *req_headers,
                                                         char **req_method,
                                                         char **req_path,
                                                         SoupHTTPVersion *ver);

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_headers_parse_response ()

gboolean            soup_headers_parse_response         (const char *str,
                                                         int len,
                                                         SoupMessageHeaders *headers,
                                                         SoupHTTPVersion *ver,
                                                         guint *status_code,
                                                         char **reason_phrase);

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.

soup_headers_parse_status_line ()

gboolean            soup_headers_parse_status_line      (const char *status_line,
                                                         SoupHTTPVersion *ver,
                                                         guint *status_code,
                                                         char **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".

soup_headers_parse ()

gboolean            soup_headers_parse                  (const char *str,
                                                         int len,
                                                         SoupMessageHeaders *dest);

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().

Since 2.26

soup_header_parse_list ()

GSList*             soup_header_parse_list              (const char *header);

Parses a header whose content is described by RFC2616 as "something", where "something" does not itself contain commas, except as part of quoted-strings.

soup_header_parse_quality_list ()

GSList*             soup_header_parse_quality_list      (const char *header,
                                                         GSList **unacceptable);

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.

soup_header_free_list ()

void                soup_header_free_list               (GSList *list);

Frees list.

soup_header_contains ()

gboolean            soup_header_contains                (const char *header,
                                                         const char *token);

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.

soup_header_parse_param_list ()

GHashTable*         soup_header_parse_param_list        (const char *header);

Parses a header which is a comma-delimited list of something like: token [ "=" ( token | quoted-string ) ].

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 RFC2231 encoding (which in HTTP is mostly used for giving UTF8-encoded filenames in the Content-Disposition header).

soup_header_parse_semi_param_list ()

GHashTable*         soup_header_parse_semi_param_list   (const char *header);

Parses a header which is a semicolon-delimited list of something like: token [ "=" ( token | quoted-string ) ].

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 RFC2231 encoding (which in HTTP is mostly used for giving UTF8-encoded filenames in the Content-Disposition header).

Since 2.24

soup_header_free_param_list ()

void                soup_header_free_param_list         (GHashTable *param_list);

Frees param_list.

soup_header_g_string_append_param ()

void                soup_header_g_string_append_param   (GString *string,
                                                         const char *name,
                                                         const char *value);

Appends something like name="value" to string, taking care to appropriately escape any quotes or backslashes in value.

Alternatively, if value is a non-ASCII UTF-8 string, it will be appended using RFC2231 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.

Since 2.26

soup_str_case_equal ()

gboolean            soup_str_case_equal                 (gconstpointer v1,
                                                         gconstpointer v2);

Compares v1 and v2 in a case-insensitive manner

soup_str_case_hash ()

guint               soup_str_case_hash                  (gconstpointer key);

Hashes key in a case-insensitive manner.

soup_add_completion ()

GSource*            soup_add_completion                 (GMainContext *async_context,
                                                         GSourceFunc function,
                                                         gpointer data);

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.

Since 2.24

soup_add_idle ()

GSource*            soup_add_idle                       (GMainContext *async_context,
                                                         GSourceFunc function,
                                                         gpointer data);

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.

soup_add_io_watch ()

GSource*            soup_add_io_watch                   (GMainContext *async_context,
                                                         GIOChannel *chan,
                                                         GIOCondition condition,
                                                         GIOFunc function,
                                                         gpointer data);

Adds an I/O watch as with g_io_add_watch(), but using the given async_context.

soup_add_timeout ()

GSource*            soup_add_timeout                    (GMainContext *async_context,
                                                         guint interval,
                                                         GSourceFunc function,
                                                         gpointer data);

Adds a timeout as with g_timeout_add(), but using the given async_context.

soup_ssl_supported

extern const gboolean soup_ssl_supported;

Can be used to test if libsoup was compiled with ssl support.