kibi-swipl-linux-x64-gnu 1.0.0

package/lib/swipl/library/ext/ssl/xmlenc.pl

@@ -0,0 +1,354 @@
+/*  Part of SWI-Prolog
+
+    Author:        Matt Lilley
+    E-mail:        thetrime@gmail.com
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2004-2016, SWI-Prolog Foundation
+                              VU University Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+
+:-module(xmlenc,
+         [ decrypt_xml/4,   % +EncryptedXML, -DecryptedXML, :KeyCallback, +Options
+           load_certificate_from_base64_string/2 % +Base64String, -Certificate
+         ]).
+:- autoload(library(base64),[base64/2]).
+:- autoload(library(crypto),
+	    [crypto_data_decrypt/6,rsa_private_decrypt/4,hex_bytes/2]).
+:- autoload(library(error),[existence_error/2,domain_error/2]).
+:- autoload(library(lists),[append/3]).
+:- autoload(library(sgml),[load_structure/3]).
+:- autoload(library(ssl),[load_certificate/2]).
+:- autoload(library(uri),[uri_components/2]).
+:- autoload(library(http/http_open),[http_open/3]).
+
+:- meta_predicate
+    decrypt_xml(+, -, 3, +).
+
+/** <module> XML encryption library
+
+This library is a partial implementation of the XML encryption standard.
+It implements the _decryption_ part, which is needed by SAML clients.
+
+@see https://www.w3.org/TR/xmlenc-core1/
+@see https://en.wikipedia.org/wiki/Security_Assertion_Markup_Language
+*/
+
+% These are the 4 mandatory block cipher algorithms
+% (actually aes-192-cbc is not mandatory, but it is easy to support)
+ssl_algorithm('http://www.w3.org/2001/04/xmlenc#tripledes-cbc', 'des3',         8).
+ssl_algorithm('http://www.w3.org/2001/04/xmlenc#aes128-cbc',    'aes-128-cbc', 16).
+ssl_algorithm('http://www.w3.org/2001/04/xmlenc#aes256-cbc',    'aes-256-cbc', 32).
+ssl_algorithm('http://www.w3.org/2001/04/xmlenc#aes192-cbc',    'aes-192-cbc', 24).
+
+%!  decrypt_xml(+DOMIn, -DOMOut, :KeyCallback, +Options) is det.
+%
+%   @arg KeyCallback may be called as follows:
+%           - call(KeyCallback, name,        KeyName,         Key)
+%           - call(KeyCallback, public_key,  public_key(RSA), Key)
+%           - call(KeyCallback, certificate, Certificate,     Key)
+
+decrypt_xml([], [], _, _):- !.
+decrypt_xml([element(ns(_, 'http://www.w3.org/2001/04/xmlenc#'):'EncryptedData',
+                     Attributes, EncryptedData)|Siblings],
+            [Decrypted|NewSiblings], KeyCallback, Options) :-
+    !,
+    decrypt_element(Attributes, EncryptedData, Decrypted, KeyCallback, Options),
+    decrypt_xml(Siblings, NewSiblings, KeyCallback, Options).
+
+decrypt_xml([element(Tag, Attributes, Children)|Siblings],
+            [element(Tag, Attributes, NewChildren)|NewSiblings], KeyCallback, Options) :-
+    !,
+    decrypt_xml(Children, NewChildren, KeyCallback, Options),
+    decrypt_xml(Siblings, NewSiblings, KeyCallback, Options).
+decrypt_xml([Other|Siblings], [Other|NewSiblings], KeyCallback, Options):-
+    decrypt_xml(Siblings, NewSiblings, KeyCallback, Options).
+
+%!   decrypt_element(+Attributes,
+%!                   +EncryptedData,
+%!                   -DecryptedElement,
+%!                   +Options).
+%
+%    Decrypt an EncryptedData element  with   Attributes  and  child
+%    EncryptedData DecryptedElement will either be an element/3 term
+%    or a string as dictacted by   the Type attribute in Attributes.
+%    If Attributes does not contain a  Type attribute then we assume
+%    it is a string
+
+:-meta_predicate(decrypt_element(+, +, -, 3, +)).
+
+decrypt_element(Attributes, EncryptedData, Decrypted, KeyCallback, Options):-
+    XENC = ns(_, 'http://www.w3.org/2001/04/xmlenc#'),
+    (  memberchk(element(XENC:'CipherData', _, CipherData), EncryptedData)
+    -> true
+    ;  existence_error(cipher_data, EncryptedData)
+    ),
+    % The Type attribute is not mandatory. However, 3.1 states that
+    % "Without this information, the decryptor will be unable to automatically restore the XML document to its original cleartext form."
+    (  memberchk('Type'=Type, Attributes)
+    -> true
+    ;  Type = 'http://www.w3.org/2001/04/xmlenc#Content'
+    ),
+
+    % First of all, determine the algorithm used to encrypt the data
+    determine_encryption_algorithm(EncryptedData, Algorithm, IVSize),
+
+    % There are now two tasks remaining, and they seem like they ought to be quite simple, but unfortunately they are not
+    % First, we must determine the key used to encrypt the message
+    determine_key(EncryptedData, Key, KeyCallback, Options),
+
+    % Then, we must determine what the encrypted data even IS
+    % If the message includes a CipherValue then this is straightfoward - the encrypted data is the base64-encoded child
+    % of this element.
+    (  memberchk(element(XENC:'CipherValue', _, CipherValueElement), CipherData)
+    -> base64_element(CipherValueElement, CipherValueWithIV),
+           string_codes(CipherValueWithIV, CipherValueWithIVCodes),
+           length(IVCodes, IVSize),
+           append(IVCodes, CipherCodes, CipherValueWithIVCodes),
+           string_codes(IV, IVCodes),
+           string_codes(CipherText, CipherCodes),
+           length(CipherValueWithIVCodes, _),
+           crypto_data_decrypt(CipherText, Algorithm, Key, IV, DecryptedStringWithPadding, [padding(none), encoding(octet)])
+    ;  memberchk(element(XENC:'CipherReference', CipherReferenceAttributes, CipherReference), CipherData)->
+           % However, it is allowed to include CipherReference instead. This is an arbitrary URI and a list of transforms to convert the
+           % data identified by that URI into the raw octets that represent the encrypted data
+           % The URI attribute of the CipherReference element is mandatory
+           memberchk('URI'=CipherURI, CipherReferenceAttributes),
+           % The transforms attribute is optional, though.
+           (  memberchk(element('Transforms', _, Transforms), CipherReference)
+           -> true
+           ;  Transforms = []
+           ),
+           uri_components(CipherURI, uri_components(Scheme, _, _, _, _)),
+           (  ( Scheme == 'http' ; Scheme == 'https')
+              % FIXME: URI may not be an *absolute* URL
+           ->  with_output_to(string(RawCipherValue),
+                          setup_call_cleanup(http_open(CipherURI, HTTPStream, []),
+                                             copy_stream_data(HTTPStream, current_output),
+                                             close(HTTPStream)))
+           ;  domain_error(resolvable_uri, CipherURI)
+           ),
+           apply_ciphertext_transforms(RawCipherValue, Transforms, CipherValue),
+           sub_string(CipherValue, 0, IVSize, _, IV),
+           sub_string(CipherValue, IVSize, _, 0, CipherText),
+           crypto_data_decrypt(CipherText, Algorithm, Key, IV, DecryptedStringWithPadding, [padding(none), encoding(octet)])
+    ),
+    % The XML-ENC padding scheme does not comply with RFC-1423. This has been noted a few times by people trying to write
+    % XML-ENC decryptors backed by OpenSSL, which insists on compliance. The only recourse we have is to disable padding entirely
+    % and do it in our application
+    xmlenc_padding(DecryptedStringWithPadding, DecryptedString),
+    % Now that we have the decrypted data, we can decide whether to turn it into an element or leave it as
+    % content
+    (  Type == 'http://www.w3.org/2001/04/xmlenc#Element'
+    -> setup_call_cleanup(open_string(DecryptedString, StringStream),
+                          load_structure(StringStream, [Decrypted], [dialect(xmlns), keep_prefix(true)]),
+                          close(StringStream))
+    ;  Decrypted = DecryptedString
+    ).
+
+xmlenc_padding(DecryptedStringWithPadding, DecryptedString):-
+    string_length(DecryptedStringWithPadding, _),
+    string_codes(DecryptedStringWithPadding, Codes),
+    append(_, [LastCode], Codes),
+    length(Padding, LastCode),
+    append(DecryptedCodes, Padding, Codes),
+    !,
+    string_codes(DecryptedString, DecryptedCodes).
+
+apply_ciphertext_transforms(CipherValue, [], CipherValue):- !.
+apply_ciphertext_transforms(_, [_AnythingElse|_], _):-
+    % FIXME: Not implemented
+    throw(error(implementation_missing('CipherReference transforms are not implemented', _))).
+
+:- meta_predicate determine_key(+,-,3,+).
+determine_key(EncryptedData, Key, KeyCallback, Options):-
+    DS = ns(_, 'http://www.w3.org/2000/09/xmldsig#'),
+    (  memberchk(element(DS:'KeyInfo', _, KeyInfo), EncryptedData)
+    -> true
+    ;  % Technically the KeyInfo is not mandatory. However, without a key we cannot decrypt
+           % so raise an error. In the future Options could contain a key if it is agreed upon
+           % by some other channel
+           existence_error(key_info, EncryptedData)
+    ),
+    resolve_key(KeyInfo, Key, KeyCallback, Options).
+
+:- meta_predicate resolve_key(+,-,3,+).
+
+resolve_key(Info, Key, KeyCallback, Options):-
+    % EncryptedKey
+    XENC = 'http://www.w3.org/2001/04/xmlenc#',
+    memberchk(element(ns(_, XENC):'EncryptedKey', _KeyAttributes, EncryptedKey), Info),
+    !,
+    % The EncryptedKey is slightly different to EncryptedData. For a start, the algorithms used to decrypt the
+    % key are orthogonal to those used for EncryptedData. However we can recursively search for the keys then
+    % decrypt them using the different algorithms as needed
+    memberchk(element(ns(_, XENC):'EncryptionMethod', MethodAttributes, EncryptionMethod), EncryptedKey),
+    memberchk('Algorithm'=Algorithm, MethodAttributes),
+
+    % Now find the KeyInfo
+    determine_key(EncryptedKey, PrivateKey, KeyCallback, Options),
+
+    memberchk(element(ns(_, XENC):'CipherData', _, CipherData), EncryptedKey),
+    memberchk(element(ns(_, XENC):'CipherValue', _, CipherValueElement), CipherData),
+    base64_element(CipherValueElement, CipherValue),
+    (  Algorithm == 'http://www.w3.org/2001/04/xmlenc#rsa-oaep-mgf1p'
+    -> rsa_private_decrypt(PrivateKey, CipherValue, Key, [encoding(octet), padding(pkcs1_oaep)])
+    ;  Algorithm == 'http://www.w3.org/2009/xmlenc11#rsa-oaep',
+           memberchk(element(ns(_, 'http://www.w3.org/2009/xmlenc11#'):'MGF', MGFAttributes, _), EncryptionMethod),
+           memberchk('Algorithm'='http://www.w3.org/2009/xmlenc11#mgf1sha1', MGFAttributes)   % This is just the same as rsa-oaep-mgf1p!
+    -> rsa_private_decrypt(PrivateKey, CipherValue, Key, [encoding(octet), padding(pkcs1_oaep)])
+    ;  Algorithm == 'http://www.w3.org/2001/04/xmlenc#rsa-1_5'
+    -> rsa_private_decrypt(PrivateKey, CipherValue, Key, [encoding(octet), padding(pkcs1)])
+    ;  domain_error(key_transport, Algorithm)
+    ).
+resolve_key(KeyInfo, _Key, _KeyCallback, _Options):-
+    % AgreementMethod. FIXME: Not implemented
+    XENC = ns(_, 'http://www.w3.org/2001/04/xmlenc#'),
+    memberchk(element(XENC:'AgreementMethod', _KeyAttributes, _AgreementMethod), KeyInfo),
+    !,
+    throw(not_implemented).
+% Additionally, we are allowed to use any elements from XML-DSIG
+resolve_key(KeyInfo, Key, KeyCallback, _Options):-
+    % KeyName. Use the callback with type=name and hint=KeyName
+    DS = ns(_, 'http://www.w3.org/2000/09/xmldsig#'),
+    memberchk(element(DS:'KeyName', _KeyAttributes, [KeyName]), KeyInfo),
+    !,
+    call(KeyCallback, name, KeyName, Key).
+resolve_key(KeyInfo, _Key, _KeyCallback, _Options):-
+    % RetrievalMethod. FIXME: Not implemented
+    DS = ns(_, 'http://www.w3.org/2000/09/xmldsig#'),
+    memberchk(element(DS:'RetrievalMethod', _KeyAttributes, _RetrievalMethod), KeyInfo),
+    !,
+    throw(not_implemented).
+resolve_key(KeyInfo, Key, KeyCallback, _Options):-
+    % KeyValue.
+    DS = ns(_, 'http://www.w3.org/2000/09/xmldsig#'),
+    memberchk(element(DS:'KeyValue', _KeyAttributes, KeyValue), KeyInfo),
+    !,
+    (  memberchk(element(DS:'RSAKeyValue', _, RSAKeyValue), KeyInfo)
+    -> memberchk(element(DS:'Modulus', _, [ModulusBase64]), RSAKeyValue),
+           memberchk(element(DS:'Exponent', _, [ExponentBase64]), RSAKeyValue),
+           base64_to_hex(ModulusBase64, Modulus),
+           base64_to_hex(ExponentBase64, Exponent),
+           call(KeyCallback, public_key, public_key(rsa(Modulus, Exponent, -, -, -, -, -, -)), Key)
+    ;  memberchk(element(DS:'DSAKeyValue', _, _DSAKeyValue), KeyInfo)
+    -> throw(error(not_implemented(dsa_key), _)) % FIXME: Not implemented
+    ;  existence_error(usable_key_value, KeyValue)
+    ).
+resolve_key(KeyInfo, Key, KeyCallback, _Options):-
+    % X509Data.
+    DS = ns(_, 'http://www.w3.org/2000/09/xmldsig#'),
+    memberchk(element(DS:'X509Data', _, X509Data), KeyInfo),
+    memberchk(element(DS:'X509Certificate', _, [X509Certificate]), X509Data),
+    !,
+    load_certificate_from_base64_string(X509Certificate, Certificate),
+    call(KeyCallback, certificate, Certificate, Key).
+resolve_key(KeyInfo, _Key, _KeyCallback, _Options):-
+    % PGPData. FIXME: Not implemented
+    DS = ns(_, 'http://www.w3.org/2000/09/xmldsig#'),
+    memberchk(element(DS:'PGPData', _KeyAttributes, _PGPData), KeyInfo),
+    !,
+    throw(not_implemented).
+resolve_key(KeyInfo, _Key, _KeyCallback, _Options):-
+    % SPKIData. FIXME: Not implemented
+    DS = ns(_, 'http://www.w3.org/2000/09/xmldsig#'),
+    memberchk(element(DS:'SPKIData', _KeyAttributes, _SPKIData), KeyInfo),
+    !,
+    throw(not_implemented).
+resolve_key(KeyInfo, _Key, _KeyCallback, _Options):-
+    % MgmtData. FIXME: Not implemented
+    DS = ns(_, 'http://www.w3.org/2000/09/xmldsig#'),
+    memberchk(element(DS:'MgmtData', _KeyAttributes, _SPKIData), KeyInfo),
+    !,
+    throw(not_implemented).
+resolve_key(Info, _, _, _):-
+    % The XML-ENC standard allows for arbitrary other means of transmitting keys in application-specific
+    % protocols. This is not supported here, though. In the future a callback could be provided in Options
+    % to obtain the key information from a KeyInfo structure.
+    existence_error(usable_key, Info).
+
+
+base64_to_hex(Base64, Hex):-
+    base64(Raw, Base64),
+    atom_codes(Raw, Codes),
+    hex_bytes(Hex0, Codes),
+    string_upper(Hex0, Hex).
+
+
+determine_encryption_algorithm(EncryptedData, Algorithm, IVSize):-
+    XENC = ns(_, 'http://www.w3.org/2001/04/xmlenc#'),
+    (  memberchk(element(XENC:'EncryptionMethod', EncryptionMethodAttributes, _), EncryptedData)
+    -> % This is a mandatory attribute
+           memberchk('Algorithm'=XMLAlgorithm, EncryptionMethodAttributes),
+           (  ssl_algorithm(XMLAlgorithm, Algorithm, IVSize)
+           -> true
+           ; domain_error(block_cipher, XMLAlgorithm)
+           )
+        % In theory the EncryptionMethod is optional. In pracitse though, if the method is not supplied we
+        % cannot decrypt the data. In the future we could support encryption_algorithm/1 as an option to
+        % decrypt_element/3 but for now raise an exception
+    ; existence_error(encryption_method, EncryptedData)
+    ).
+
+base64_element([CipherValueElement], CipherValue):-
+    atom_codes(CipherValueElement, Base64Codes),
+    delete_newlines(Base64Codes, TrimmedCodes),
+    string_codes(Trimmed, TrimmedCodes),
+    base64(CipherValue, Trimmed).
+
+delete_newlines([], []):- !.
+delete_newlines([13|As], B):- !, delete_newlines(As, B).
+delete_newlines([10|As], B):- !, delete_newlines(As, B).
+delete_newlines([A|As], [A|B]):- !, delete_newlines(As, B).
+
+
+
+%!	load_certificate_from_base64_string(+String, -Certificate) is det.
+%
+%	Loads a certificate from a string, adding newlines and header
+%       where appropriate so that OpenSSL 1.0.1+ will be able to parse it
+
+load_certificate_from_base64_string(UnnormalizedData, Certificate):-
+    normalize_space(codes(Codes), UnnormalizedData),
+    % Break into 64-byte chunks
+    chunk_certificate(Codes, Chunks),
+    atomics_to_string(["-----BEGIN CERTIFICATE-----"|Chunks], '\n', CompleteCertificate),
+    setup_call_cleanup(open_string(CompleteCertificate, StringStream),
+                       load_certificate(StringStream, Certificate),
+                       close(StringStream)).
+
+chunk_certificate(Codes, [Chunk|Chunks]):-
+    length(ChunkCodes, 64),
+    append(ChunkCodes, Rest, Codes),
+    !,
+    string_codes(Chunk, ChunkCodes),
+    chunk_certificate(Rest, Chunks).
+chunk_certificate([], ["-----END CERTIFICATE-----\n"]):- !.
+chunk_certificate(LastCodes, [LastChunk, "-----END CERTIFICATE-----\n"]):-
+    string_codes(LastChunk, LastCodes).

package/lib/swipl/library/ext/zlib/INDEX.pl

@@ -0,0 +1,8 @@
+/*  Creator: make/0
+
+    Purpose: Provide index for autoload
+*/
+
+index(zopen(?,?,?), zlib, zlib).
+index(gzopen(?,?,?), zlib, zlib).
+index(gzopen(?,?,?,?), zlib, zlib).

package/lib/swipl/library/ext/zlib/zlib.pl

@@ -0,0 +1,112 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2006-2016, University of Amsterdam
+                              VU University Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(zlib,
+          [ zopen/3,                    % +Stream, -ZStream, +Option
+            gzopen/3,                   % +File, +Mode, -Stream
+            gzopen/4                    % +File, +Mode, -Stream, +Options
+          ]).
+:- autoload(library(apply),[partition/4]).
+:- autoload(library(error),[must_be/2]).
+:- autoload(library(option),[merge_options/3,option/2]).
+
+:- predicate_options(zopen/3, 3,
+                     [ format(oneof([gzip,deflate,raw_deflate])),
+                       multi_part(boolean),
+                       close_parent(boolean),
+                       level(between(0,9))
+                     ]).
+:- predicate_options(gzopen/4, 4,
+                     [ pass_to(zopen/3, 3),
+                       pass_to(system:open/4, 4)
+                     ]).
+
+/** <module> Zlib wrapper for SWI-Prolog
+
+Read/write compressed data based on the zlib library.
+
+@author Jan Wielemaker
+@see    http://www.zlib.net/
+@see    http://www.swi-prolog.org/packages/zlib.html
+*/
+
+:- use_foreign_library(foreign(zlib4pl)).
+:- public zdebug/1.                     % Set debug level
+
+%!  gzopen(+File, +Mode, -Stream) is det.
+%!  gzopen(+File, +Mode, -Stream, +Options) is det.
+%
+%   Open a file compatible with the  gzip   program.  Note that if a
+%   file is opened in =append= mode,  a   second  gzip image will be
+%   added to the end of the file.   The gzip standard defines that a
+%   file can hold multiple  gzip  images   and  inflating  the  file
+%   results in a concatenated stream of all inflated images.
+%
+%   Options are passed to open/4  and   zopen/3.  Default  format is
+%   =gzip=.
+
+gzopen(File, Mode, Stream) :-
+    gzopen(File, Mode, Stream, []).
+
+gzopen(File, Mode, Stream, Options) :-
+    must_be(oneof([read,write,append]), Mode),
+    partition(zoption, Options, ZOptions0, OpenOptions),
+    merge_options(ZOptions0,
+                  [ format(gzip),
+                    close_parent(true)
+                  ], ZOptions),
+    open(File, Mode, Stream0, OpenOptions),
+    zopen(Stream0, Stream, ZOptions),
+    set_stream(Stream, file_name(File)),
+    (   option(alias(Alias), ZOptions)
+    ->  set_stream(Stream, alias(Alias))
+    ;   true
+    ).
+
+
+zoption(format(_)).
+zoption(multi_part(_)).
+zoption(level(_)).
+zoption(alias(_)).
+
+%!  http:encoding_filter(+Encoding, +In0, -In) is semidet.
+%
+%   Act as plugin for library(http/http_open) for processing content
+%   with =|Content-encoding: gzip|=
+
+http:encoding_filter(gzip, In0, In) :-
+    zopen(In0, In,
+          [ close_parent(true)
+          ]).

package/lib/swipl/library/fastrw.pl

@@ -0,0 +1,105 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  2010-2021, VU University Amsterdam
+                              SWI-Prolog Solutions b.v.
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(fastrw,
+          [ fast_read/1,                % -Term
+            fast_write/1,               % +Term
+            fast_read/2,                % +Stream, -Term
+            fast_write/2,               % +Stream, +Term
+            fast_write_to_string/3      % +Term, -String, ?Tail
+          ]).
+:- autoload(library(lists),[append/3]).
+
+
+/** <module> Fast reading and writing of terms
+
+This library provides the SICStus   and  Ciao library(fastrw) interface.
+The idea behind this library  is  to   design  a  fast serialization for
+Prolog  terms.  Ideally,  this  should    be   portable  between  Prolog
+implementation. Unfortunately there is no   portably  binary term format
+defined.
+
+The current implementation  is  based   on  PL_record_external(),  which
+provides a binary representation of terms  that is processed efficiently
+and can handle subterm sharing,  cycles   and  attributed  variables. In
+other words, this library can handle any Prolog term except _blobs_ such
+as stream handles, database references, etc. We   try to keep the format
+compatible between versions, but this is   not guaranteed. Conversion is
+always possible by reading a database  using   the  old version, dump it
+using write_canonical/1 and read it into the new version.
+
+This library is built upon the following built in predicates:
+
+  - fast_term_serialized/2 translates between a term and its
+  serialization as a byte string.
+  - fast_read/2 and fast_write/2 read/write binary serializations.
+
+@tbd    Establish a portable binary format.
+@compat The format is not compatible to SICStus/Ciao (which are not
+        compatible either).  Future versions of this library might
+        implement a different encoding.
+@bug    The current implementation of fast_read/1 __is not safe__.
+        It is guaranteed to safely read terms written using
+        fast_write/1, but may crash on arbitrary input.  The
+        implementation does perform some basic sanity checks,
+        including validation of the magic start byte.
+*/
+
+%!  fast_read(-Term)
+%
+%   The next term is read from current standard input and is unified
+%   with Term. The syntax of the term   must  agree with fast_read /
+%   fast_write format. If the end  of   the  input has been reached,
+%   Term is unified with the term =end_of_file=.
+
+fast_read(Term) :-
+    fast_read(current_input, Term).
+
+%!  fast_write(+Term)
+%
+%   Output Term in a way that   fast_read/1  and fast_read/2 will be
+%   able to read it back.
+
+fast_write(Term) :-
+    fast_write(current_output, Term).
+
+%!  fast_write_to_string(+Term, -String, ?Tail)
+%
+%   Perform a fast-write to the difference-slist String\Tail.
+
+fast_write_to_string(T, S, R) :-
+    fast_term_serialized(T, String),
+    string_codes(String, Codes),
+    append(Codes, R, S).

package/lib/swipl/library/files.pl

@@ -0,0 +1,80 @@
+/*  Part of SWI-Prolog
+
+    Author:        Jan Wielemaker
+    E-mail:        J.Wielemaker@vu.nl
+    WWW:           http://www.swi-prolog.org
+    Copyright (c)  1985-2002, University of Amsterdam
+    All rights reserved.
+
+    Redistribution and use in source and binary forms, with or without
+    modification, are permitted provided that the following conditions
+    are met:
+
+    1. Redistributions of source code must retain the above copyright
+       notice, this list of conditions and the following disclaimer.
+
+    2. Redistributions in binary form must reproduce the above copyright
+       notice, this list of conditions and the following disclaimer in
+       the documentation and/or other materials provided with the
+       distribution.
+
+    THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+    "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+    LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
+    FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
+    COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+    INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+    BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+    LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+    CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
+    LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
+    ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+    POSSIBILITY OF SUCH DAMAGE.
+*/
+
+:- module(files,
+        [ can_open_file/2,              % +Path, +Mode
+          chdir/1                       % +Dir
+        ]).
+
+%!  can_open_file(+Path, +Mode)
+%
+%   Succeeds if the user has access to `File' in mode `Mode'.  Fails
+%   silently if this is not the  case.   `Mode'  is  one  of  {read,
+%   write, both}.  This used to be difficult.  Since we have
+%   access_file/2 it is merely a Quintus compatibility predicate
+%   and should be in quintus.pl.  We will leave it here for compatibility
+%   reasons.
+%
+%   @deprecated Use access_file/2.
+
+can_open_file(File, read) :-
+    !,
+    access_file(File, read).
+can_open_file(File, write) :-
+    !,
+    (   exists_file(File)
+    ->  access_file(File, write)
+    ;   path_dir_name(File, Dir),
+        access_file(Dir, write)
+    ).
+can_open_file(File, both) :-
+    access_file(File, read),
+    access_file(File, write).
+
+path_dir_name(File, Dir) :-
+    file_base_name(File, Base),
+    atom_concat(RawDir, Base, File),
+    (   RawDir == ''
+    ->  Dir = '.'
+    ;   Dir = RawDir
+    ).
+
+%!  chdir(+Dir) is det.
+%
+%   Change Working Directory.
+%
+%   @deprecated     Use using working_directory/2.
+
+chdir(Dir) :-
+    working_directory(_Old, Dir).