Functions
- check_version(major: int, minor: int, micro: int) bool
Like
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.
- Parameters:
major – the major version to check
minor – the minor version to check
micro – the micro version to check
- Returns:
True
if the version of the libsoup currently loaded is the same as or newer than the passed-in version.
- cookies_from_request(msg: Message) list[Cookie]
Parses
msg
’s Cookie request header and returns aSList
ofSoupCookie
’s.As the “Cookie” header, unlike “Set-Cookie”, only contains cookie names and values, none of the other
Cookie
fields will be filled in. (Thus, you can’t generally pass a cookie returned from this method directly tocookies_to_response
.)- Parameters:
msg – a
Message
containing a “Cookie” request header- Returns:
a
GSList
ofSoupCookie
’s, which can be freed withfree
.
- cookies_from_response(msg: Message) list[Cookie]
Parses
msg
’s Set-Cookie response headers and returns aSList
ofSoupCookie
’s.Cookies that do not specify “path” or “domain” attributes will have their values defaulted from
msg
.- Parameters:
msg – a
Message
containing a “Set-Cookie” response header- Returns:
a
GSList
ofSoupCookie
’s, which can be freed withfree
.
- cookies_to_cookie_header(cookies: list[Cookie]) str
Serializes a
SList
ofCookie
into a string suitable for setting as the value of the “Cookie” header.- Parameters:
cookies – a
GSList
ofCookie
- Returns:
the serialization of
cookies
- cookies_to_request(cookies: list[Cookie], msg: Message) None
Adds the name and value of each cookie in
cookies
tomsg
’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.
- cookies_to_response(cookies: list[Cookie], msg: Message) None
Appends a “Set-Cookie” response header to
msg
for each cookie incookies
.This is in addition to any other “Set-Cookie” headers
msg
may already have.
- date_time_new_from_http_string(date_string: str) DateTime | None
Parses
date_string
and tries to extract a date from it.This recognizes all of the “HTTP-date” formats from RFC 2616, RFC 2822 dates, and reasonable approximations thereof. (Eg, it is lenient about whitespace, leading “0”s, etc.)
- Parameters:
date_string – The date as a string
- Returns:
a new
DateTime
, orNone
ifdate_string
could not be parsed.
- date_time_to_string(date: DateTime, format: DateFormat) str
Converts
date
to a string in the format described byformat
.- Parameters:
date – a
DateTime
format – the format to generate the date in
- Returns:
date
as a string orNone
- form_decode(encoded_form: str) dict[str, str]
Decodes
form
.which is an urlencoded dataset as defined in the HTML 4.01 spec.
- Parameters:
encoded_form – data of type “application/x-www-form-urlencoded”
- Returns:
a hash table containing the name/value pairs from
encoded_form
, which you can free withdestroy
.
- form_decode_multipart(multipart: Multipart, file_control_name: str | None = None) tuple[dict[str, str] | None, str, str, Bytes]
Decodes the “multipart/form-data” request in
multipart
.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
, andform_decode_multipart
will extract the uploaded file data intofilename
,content_type
, andfile
. All of the other form control data will be returned (as strings, as withform_decode
in the returnedHashTable
.You may pass
None
forfilename
,content_type
and/orfile
if you do not care about those fields.form_decode_multipart
may also returnNone
in those fields if the client did not provide that information. You must free the returned filename and content-type withfree
, and the returned file data withunref
.If you have a form with more than one file upload control, you will need to decode it manually, using
new_from_message
andget_part
.
- form_encode_datalist(form_data_set: Data) str
Encodes
form_data_set
into a value of type “application/x-www-form-urlencoded”.Encodes as defined in the HTML 4.01 spec. Unlike
form_encode_hash
, this preserves the ordering of the form elements, which may be required in some situations.See also:
new_from_encoded_form
.- Parameters:
form_data_set – a datalist containing name/value pairs
- Returns:
the encoded form
- form_encode_hash(form_data_set: dict[str, str]) str
Encodes
form_data_set
into a value of type “application/x-www-form-urlencoded”.Encodes 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
form_encode_datalist
.See also:
new_from_encoded_form
.- Parameters:
form_data_set – a hash table containing name/value pairs (as strings)
- Returns:
the encoded form
- get_major_version() int
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.- Returns:
the major version number of the libsoup library
- get_micro_version() int
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.- Returns:
the micro version number of the libsoup library
- get_minor_version() int
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.- Returns:
the minor version number of the libsoup library
- header_contains(header: str, token: str) bool
Parses
header
to see if it contains the tokentoken
(matched case-insensitively).Note that this can’t be used with lists that have qvalues.
- Parameters:
header – An HTTP header suitable for parsing with
header_parse_list
token – a token
- Returns:
whether or not
header
containstoken
- header_free_param_list(param_list: dict[str, str]) None
Frees
param_list
.- Parameters:
param_list – a
HashTable
returned fromheader_parse_param_list
orheader_parse_semi_param_list
- header_g_string_append_param(string: String, name: str, value: str | None = None) None
Appends something like
name=value
tostring
, taking care to quotevalue
if needed, and if so, to escape any quotes or backslashes invalue
.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
isNone
, this will just appendname
tostring
.- Parameters:
string – a
String
being used to construct an HTTP header valuename – a parameter name
value – a parameter value, or
None
- header_g_string_append_param_quoted(string: String, name: str, value: str) None
Appends something like
name="value"
tostring
, taking care to escape any quotes or backslashes invalue
.If
value
is (non-ASCII) UTF-8, this will instead use RFC 5987 encoding, just likeheader_g_string_append_param
.- Parameters:
string – a
String
being used to construct an HTTP header valuename – a parameter name
value – a parameter value
- header_parse_list(header: str) list[str]
Parses a header whose content is described by RFC2616 as
``something``
.“something” does not itself contain commas, except as part of quoted-strings.
- Parameters:
header – a header value
- Returns:
a
GSList
of list elements, as allocated strings
- header_parse_param_list(header: str) dict[str, str]
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
None
value.This also handles RFC5987 encoding (which in HTTP is mostly used for giving UTF8-encoded filenames in the Content-Disposition header).
- Parameters:
header – a header value
- Returns:
a
HashTable
of list elements, which can be freed withheader_free_param_list
.
- header_parse_param_list_strict(header: str) dict[str, str] | None
A strict version of
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
header_parse_param_list
instead.- Parameters:
header – a header value
- Returns:
a
HashTable
of list elements, which can be freed withheader_free_param_list
orNone
if there are duplicate elements.
- header_parse_quality_list(header: str) tuple[list[str], list[str]]
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 notNone
, then on return, it will contain the items with qvalue 0. Either way, those items will be removed from the main list.- Parameters:
header – a header value
- Returns:
a
GSList
of acceptable values (as allocated strings), highest-qvalue first.
- header_parse_semi_param_list(header: str) dict[str, str]
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
None
value.This also handles RFC5987 encoding (which in HTTP is mostly used for giving UTF8-encoded filenames in the Content-Disposition header).
- Parameters:
header – a header value
- Returns:
a
HashTable
of list elements, which can be freed withheader_free_param_list
.
- header_parse_semi_param_list_strict(header: str) dict[str, str] | None
A strict version of
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
header_parse_semi_param_list
instead.- Parameters:
header – a header value
- Returns:
a
HashTable
of list elements, which can be freed withheader_free_param_list
orNone
if there are duplicate elements.
- headers_parse(str: str, len: int, dest: MessageHeaders) bool
Parses the headers of an HTTP request or response in
str
and stores the results indest
.Beware that
dest
may be modified even on failure.This is a low-level method; normally you would use
headers_parse_request
orheaders_parse_response
.- Parameters:
str – the header string (including the Request-Line or Status-Line, but not the trailing blank line)
len – length of
str
dest –
MessageHeaders
to store the header values in
- Returns:
success or failure
- headers_parse_request(str: str, len: int, req_headers: MessageHeaders) tuple[int, str, str, HTTPVersion]
Parses the headers of an HTTP request in
str
and stores the results inreq_method
,req_path
,ver
, andreq_headers
.Beware that
req_headers
may be modified even on failure.- Parameters:
str – the headers (up to, but not including, the trailing blank line)
len – length of
str
req_headers –
MessageHeaders
to store the header values in
- Returns:
OK
if the headers could be parsed, or an HTTP error to be returned to the client if they could not be.
- headers_parse_response(str: str, len: int, headers: MessageHeaders) tuple[bool, HTTPVersion, int, str]
Parses the headers of an HTTP response in
str
and stores the results inver
,status_code
,reason_phrase
, andheaders
.Beware that
headers
may be modified even on failure.- Parameters:
str – the headers (up to, but not including, the trailing blank line)
len – length of
str
headers –
MessageHeaders
to store the header values in
- Returns:
success or failure.
- headers_parse_status_line(status_line: str) tuple[bool, HTTPVersion, int, str]
Parses the HTTP Status-Line string in
status_line
intover
,status_code
, andreason_phrase
.status_line
must be terminated by either “0” or “rn”.- Parameters:
status_line – an HTTP Status-Line
- Returns:
True
ifstatus_line
was parsed successfully.
- message_headers_iter_init(hdrs: MessageHeaders) MessageHeadersIter
- Parameters:
hdrs
- tld_domain_is_public_suffix(domain: str) bool
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.- Parameters:
domain – a domain name
- Returns:
True
if it is a public domain,False
otherwise.
- tld_get_base_domain(hostname: str) str
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
None
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).- Parameters:
hostname – a hostname
- Returns:
a pointer to the start of the base domain in
hostname
. If an error occurs,None
will be returned anderror
set.
- uri_decode_data_uri(uri: str) tuple[Bytes, str]
Decodes the given data URI and returns its contents and
content_type
.- Parameters:
uri – a data URI, in string form
- Returns:
a
Bytes
with the contents ofuri
, orNone
ifuri
is not a valid data URI
- websocket_client_prepare_handshake(msg: Message, origin: str | None = None, protocols: Sequence[str] | None = None, supported_extensions: Sequence[TypeClass] | None = None) None
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
websocket_connect_async
to create a WebSocket connection, it will call this for you.- Parameters:
msg – a
Message
origin – the “Origin” header to set
protocols – list of protocols to offer
supported_extensions – list of supported extension types
- websocket_client_verify_handshake(msg: Message, supported_extensions: Sequence[TypeClass] | None = None) tuple[bool, list[WebsocketExtension]]
Looks at the response status code and headers in
msg
and determines if they contain a valid WebSocket handshake response (given the handshake request inmsg
’s request headers).If
supported_extensions
is non-None
, extensions included in the response “Sec-WebSocket-Extensions” are verified too. Accepted extensions are returned inaccepted_extensions
parameter if non-None
.This is a low-level function; if you use
websocket_connect_async
to create a WebSocket connection, it will call this for you.- Parameters:
msg –
Message
containing both client and server sides of a WebSocket handshakesupported_extensions – list of supported extension types
- Returns:
True
ifmsg
contains a completed valid WebSocket handshake,False
and an error if not.
- websocket_server_check_handshake(msg: ServerMessage, origin: str | None = None, protocols: Sequence[str] | None = None, supported_extensions: Sequence[TypeClass] | None = None) bool
Examines the method and request headers in
msg
and determines whethermsg
contains a valid handshake request.If
origin
is non-None
, then only requests containing a matching “Origin” header will be accepted. Ifprotocols
is non-None
, then only requests containing a compatible “Sec-WebSocket-Protocols” header will be accepted. Ifsupported_extensions
is non-None
, then only requests containing valid supported extensions in “Sec-WebSocket-Extensions” header will be accepted.Normally
websocket_server_process_handshake
will take care of this for you, and if you useadd_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.- Parameters:
msg –
ServerMessage
containing the client side of a WebSocket handshakeorigin – expected Origin header
protocols – allowed WebSocket protocols.
supported_extensions – list of supported extension types
- Returns:
True
ifmsg
contained a valid WebSocket handshake,False
and an error if not.
- websocket_server_process_handshake(msg: ServerMessage, expected_origin: str | None = None, protocols: Sequence[str] | None = None, supported_extensions: Sequence[TypeClass] | None = None) tuple[bool, list[WebsocketExtension]]
Examines the method and request headers in
msg
and (assumingmsg
contains a valid handshake request), fills in the handshake response.If
expected_origin
is non-None
, then only requests containing a matching “Origin” header will be accepted. Ifprotocols
is non-None
, then only requests containing a compatible “Sec-WebSocket-Protocols” header will be accepted. Ifsupported_extensions
is non-None
, then only requests containing valid supported extensions in “Sec-WebSocket-Extensions” header will be accepted. The accepted extensions will be returned inaccepted_extensions
parameter if non-None
.This is a low-level function; if you use
add_websocket_handler
to handle accepting WebSocket connections, it will call this for you.- Parameters:
msg –
ServerMessage
containing the client side of a WebSocket handshakeexpected_origin – expected Origin header
protocols – allowed WebSocket protocols.
supported_extensions – list of supported extension types
- Returns:
True
ifmsg
contained a valid WebSocket handshake request and was updated to contain a handshake response.False
if not.