3.20 library(http/http_header): Handling HTTP headers

The library library(http/http_header) provides primitives for parsing and composing HTTP headers. Its functionality is normally hidden by the other parts of the HTTP server and client libraries.

[det]http_read_request(+FdIn:stream, -Request)

Read an HTTP request-header from FdIn and return the broken-down request fields as +Name(+Value) pairs in a list. Request is unified to end_of_file if FdIn is at the end of input.

http_read_reply_header(+FdIn, -Reply)

Read the HTTP reply header. Throws an exception if the current input does not contain a valid reply header.

[det]http_reply(+Data, +Out:stream)

[det]http_reply(+Data, +Out:stream, +HdrExtra)

[det]http_reply(+Data, +Out:stream, +HdrExtra, -Code)

[det]http_reply(+Data, +Out:stream, +HdrExtra, +Context, -Code)

[det]http_reply(+Data, +Out:stream, +HdrExtra, +Context, +Request, -Code)

Compose a complete HTTP reply from the term Data using additional headers from HdrExtra to the output stream Out. ExtraHeader is a list of Field(Value). Data is one of:

html(HTML)

HTML tokens as produced by html//1 from html_write.pl

file(+MimeType, +FileName)

Reply content of FileName using MimeType

file(+MimeType, +FileName, +Range)

Reply partial content of FileName with given MimeType

tmp_file(+MimeType, +FileName)

Same as file, but do not include modification time

bytes(+MimeType, +Bytes)

Send a sequence of Bytes with the indicated MimeType. Bytes is either a string of character codes 0..255 or list of integers in the range 0..255. Out-of-bound codes result in a representation error exception.

stream(+In, +Len)

Reply content of stream.

cgi_stream(+In, +Len)

Reply content of stream, which should start with an HTTP header, followed by a blank line. This is the typical output from a CGI script.

Status

HTTP status report as defined by http_status_reply/4.

HdrExtra	provides additional reply-header fields, encoded as Name(Value). It can also contain a field content_length(-Len) to retrieve the value of the Content-length header that is replied.
Code	is the numeric HTTP status code sent

To be done

Complete documentation

[det]http_status_reply(+Status, +Out, +HdrExtra, -Code)

[det]http_status_reply(+Status, +Out, +HdrExtra, +Context, -Code)

[det]http_status_reply(+Status, +Out, +HdrExtra, +Context, +Request, -Code)

Emit HTML non-200 status reports. Such requests are always sent as UTF-8 documents.

Status can be one of the following:

authorise(Method)

Challenge authorization. Method is one of

• basic(Realm)
• digest(Digest)

authorise(basic, Realm)

Same as authorise(basic(Realm)). Deprecated.

bad_request(ErrorTerm)

busy

created(Location)

forbidden(Url)

moved(To)

moved_temporary(To)

no_content

not_acceptable(WhyHtml)

not_found(Path)

method_not_allowed(Method, Path)

not_modified

resource_error(ErrorTerm)

see_other(To)

switching_protocols(Goal, Options)

server_error(ErrorTerm)

unavailable(WhyHtml)

[semidet,multifile]http:serialize_reply(+Reply, -Body)

Multifile hook to serialize the result of http:status_reply/3 into a term

body(Type, Encoding, Content)

In this term, Type is the media type, Encoding is the required wire encoding and Content a string representing the content.

http_join_headers(+Default, +Header, -Out)

Append headers from Default to Header if they are not already part of it.

http_update_encoding(+HeaderIn, -Encoding, -HeaderOut)

Allow for rewrite of the header, adjusting the encoding. We distinguish three options. If the user announces‘text’, we always use UTF-8 encoding. If the user announces charset=utf-8 we use UTF-8 and otherwise we use octet (raw) encoding. Alternatively we could dynamically choose for ASCII, ISO-Latin-1 or UTF-8.

[semidet,multifile]http:mime_type_encoding(+MimeType, -Encoding)

Encoding is the (default) character encoding for MimeType. This is used for setting the encoding for HTTP replies after the user calls format('Content-type: <MIME type>~n'). This hook is called before mime_type_encoding/2. This default defines utf8 for JSON and Turtle derived application/ MIME types.

http_update_connection(+CGIHeader, +Request, -Connection, -Header)

Merge keep-alive information from Request and CGIHeader into Header.

http_update_transfer(+Request, +CGIHeader, -Transfer, -Header)

Decide on the transfer encoding from the Request and the CGI header. The behaviour depends on the setting http:chunked_transfer. If never, even explitic requests are ignored. If on_request, chunked encoding is used if requested through the CGI header and allowed by the client. If if_possible, chunked encoding is used whenever the client allows for it, which is interpreted as the client supporting HTTP 1.1 or higher.

Chunked encoding is more space efficient and allows the client to start processing partial results. The drawback is that errors lead to incomplete pages instead of a nicely formatted complete page.

[det]http_post_data(+Data, +Out:stream, +HdrExtra)

Send data on behalf on an HTTP POST request. This predicate is normally called by http_post/4 from http_client.pl to send the POST data to the server. Data is one of:

• html(+Tokens) Result of html//1 from html_write.pl
• json(+Term) Posting a JSON query and processing the JSON reply (or any other reply understood by http_read_data/3) is simple as http_post(URL, json(Term), Reply, []), where Term is a JSON term as described in json.pl and reply is of the same format if the server replies with JSON, when using module :- use_module(library(http/http_json)). Note that the module is used in both http server and http client, see library(http/http_json).
• xml(+Term) Post the result of xml_write/3 using the Mime-type text/xml
• xml(+Type, +Term) Post the result of xml_write/3 using the given Mime-type and an empty option list to xml_write/3.
• xml(+Type, +Term, +Options) Post the result of xml_write/3 using the given Mime-type and option list for xml_write/3.
• file(+File) Send contents of a file. Mime-type is determined by file_mime_type/2.
• file(+Type, +File) Send file with content of indicated mime-type.
• memory_file(+Type, +Handle) Similar to file(+Type, +File), but using a memory file instead of a real file. See new_memory_file/1.
• codes(+Codes) As codes(text/plain, Codes).
• codes(+Type, +Codes) Send Codes using the indicated MIME-type.
• bytes(+Type, +Bytes) Send Bytes using the indicated MIME-type. Bytes is either a string of character codes 0..255 or list of integers in the range 0..255. Out-of-bound codes result in a representation error exception.
• atom(+Atom) As atom(text/plain, Atom).
• atom(+Type, +Atom) Send Atom using the indicated MIME-type.
• string(+String)
• string(+Type, +String) Similar to atom(Atom) and atom(Type,Atom), accepting a SWI-Prolog string.
• cgi_stream(+Stream, +Len) Read the input from Stream which, like CGI data starts with a partial HTTP header. The fields of this header are merged with the provided HdrExtra fields. The first Len characters of Stream are used.
• form(+ListOfParameter) Send data of the MIME type application/x-www-form-urlencoded as produced by browsers issuing a POST request from an HTML form. ListOfParameter is a list of Name=Value or Name(Value).
• form_data(+ListOfData) Send data of the MIME type multipart/form-data as produced by browsers issuing a POST request from an HTML form using enctype multipart/form-data. ListOfData is the same as for the List alternative described below. Below is an example. Repository, etc. are atoms providing the value, while the last argument provides a value from a file.

  ...,
  http_post([ protocol(http),
              host(Host),
              port(Port),
              path(ActionPath)
            ],
            form_data([ repository = Repository,
                        dataFormat = DataFormat,
                        baseURI    = BaseURI,
                        verifyData = Verify,
                        data       = file(File)
                      ]),
            _Reply,
            []),
  ...,

• List If the argument is a plain list, it is sent using the MIME type multipart/mixed and packed using mime_pack/3. See mime_pack/3 for details on the argument format.

[det]http_reply_header(+Out:stream, +What, +HdrExtra)

Create a reply header using reply_header//3 and send it to Stream.

[semidet]http_parse_header_value(+Field, +Value, -Prolog)

Translate Value in a meaningful Prolog term. Field denotes the HTTP request field for which we do the translation. Supported fields are:

content_length

Converted into an integer

status

Converted into an integer

cookie

Converted into a list with Name=Value by cookies//1.

set_cookie

Converted into a term set_cookie(Name, Value, Options). Options is a list consisting of Name=Value or a single atom (e.g., secure)

host

Converted to HostName:Port if applicable.

range

Converted into bytes(From, To), where From is an integer and To is either an integer or the atom end.

accept

Parsed to a list of media descriptions. Each media is a term media(Type, TypeParams, Quality, AcceptExts). The list is sorted according to preference.

content_disposition

Parsed into disposition(Name, Attributes), where Attributes is a list of Name=Value pairs.

content_type

Parsed into media(Type/SubType, Attributes), where Attributes is a list of Name=Value pairs.

expires

Parsed into a time stamp using http_timestamp/2.

As some fields are already parsed in the Request, this predicate is a no-op when called on an already parsed field.

Value

is either an atom, a list of codes or an already parsed header value.

[det]http_timestamp(?Time:timestamp, ?Text:atom)

Convert between a SWI-Prolog time stamp and a string in HTTP format (RFC1123). When parsing, it accepts RFC1123, RFC1036 and ASCTIME formats. See parse_time/3.

Errors

syntax_error(http_timestamp(Text)) if the string cannot be parsed.

[det]http_read_header(+Fd, -Header)

Read Name: Value lines from FD until an empty line is encountered. Field-name are converted to Prolog conventions (all lower, _ instead of -): Content-Type: text/html --> content_type(text/html)

[det]http_parse_header(+Text:codes, -Header:list)

Header is a list of Name(Value)-terms representing the structure of the HTTP header in Text.

Errors

domain_error(http_request_line, Line)

[det,multifile]http://(http_address)

HTML-rule that emits the location of the HTTP server. This hook is called from address//0 to customise the server address. The server address is emitted on non-200-ok replies.

[semidet,multifile]http:status_page(+Status, +Context, -HTMLTokens)

Hook called by http_status_reply/4 and http_status_reply/5 that allows for emitting custom error pages for the following HTTP page types:

• 201 - created(Location)
• 301 - moved(To)
• 302 - moved_temporary(To)
• 303 - see_other(To)
• 400 - bad_request(ErrorTerm)
• 401 - authorise(AuthMethod)
• 403 - forbidden(URL)
• 404 - not_found(URL)
• 405 - method_not_allowed(Method,URL)
• 406 - not_acceptable(Why)
• 500 - server_error(ErrorTerm)
• 503 - unavailable(Why)

The hook is tried twice, first using the status term, e.g., not_found(URL) and than with the code, e.g. 404. The second call is deprecated and only exists for compatibility.

Context	is the 4th argument of http_status_reply/5, which is invoked after raising an exception of the format http_reply(Status, HeaderExtra, Context). The default context is [] (the empty list).
HTMLTokens	is a list of tokens as produced by html//1. It is passed to print_html/2.