The Gz module contains functions to compress and uncompress strings using the same algorithm as the program gzip. Compressing can be done in streaming mode or all at once.
The Gz module consists of two classes; Gz.deflate and Gz.inflate. Gz.deflate is used to pack data and Gz.inflate is used to unpack data. (Think "inflatable boat")
Note that this module is only available if the gzip library was available when Pike was compiled.
Note that although these functions use the same algorithm as gzip, they do not use the exact same format, so you cannot directly unzip gzipped files with these routines. Support for this will be added in the future.
inherit _Gz : _Gz
string(8bit)|zero check_header(Stdio.Stream|void f, Stdio.Buffer|string(8bit)|void buf)
Check whether a file has a valid gzip header.
fFile to check.
bufPrefix of f.
Returns the content of f after the gzip header
if a header was found. Returns 0 (zero)
if there was no header.
int make_header(Stdio.Stream|Stdio.Buffer f)
Write a gzip header to a file or buffer.
fFile or buffer to write a gzip header to.
Returns 1 on success and 0 (zero)
on failure.
inherit ._file : _file
Allows the user to open a Gzip archive and read and write
it's contents in an uncompressed form, emulating the Stdio.File
interface.
An important limitation on this class is that it may only be used for reading or writing, not both at the same time. Please also note that if you want to reopen a file for reading after a write, you must close the file before calling open or strange effects might be the result.
Gz.File Gz.File(void|string|int|Stdio.Stream file, void|string mode)
fileFilename or filedescriptor of the gzip file to open, or an already open Stream.
modemode for the file. Defaults to "rb".
open Stdio.File
String.SplitIterator|Stdio.LineIterator line_iterator(int|void trim)
Returns an iterator that will loop over the lines in this file. If trim is true, all '\r' characters will be removed from the input.
int open(string|int|Stdio.Stream file, void|string mode)
fileFilename or filedescriptor of the gzip file to open, or an already open Stream.
modemode for the file. Defaults to "rb". May be one of the following:
read mode
write mode
append mode
For the wb and ab mode, additional parameters may be specified. Please se zlib manual for more info.
non-zero if successful.
int|string read(void|int length)
Reads data from the file. If no argument is given, the whole file is read.
function(:string) read_function(int nbytes)
Returns a function that when called will call read with
nbytes as argument. Can be used to get various callback
functions, eg for the fourth argument to
String.SplitIterator.
Low-level implementation of read/write support for GZip files
int close()
closes the file
1 if successful
Gz._file Gz._file(void|string|Stdio.Stream gzFile, void|string mode)
Opens a gzip file for reading.
bool eof()
1 if EOF has been reached.
int open(string|int|Stdio.Stream file, void|string mode)
Opens a file for I/O.
fileThe filename or an open filedescriptor or Stream for the GZip file to use.
modeMode for the file operations. Defaults to read only. The following mode characters are unique to Gz.File.
| Values 0 to 9 set the compression level from no compression to maximum available compression. Defaults to 6. |
| |
| |
| |
| |
| |
| |
| |
| |
| |
| Sets the compression strategy to |
| Sets the compression strategy to |
If the object already has been opened, it will first be closed.
int|string read(int len)
Reads len (uncompressed) bytes from the file. If read is unsuccessful, 0 is returned.
int seek(int pos, void|int type)
Seeks within the file.
posPosition relative to the searchtype.
typeSEEK_SET = set current position in file to pos SEEK_CUR = new position is current+pos SEEK_END is not supported.
New position or negative number if seek failed.
int setparams(void|int(0..9) level, void|int strategy, void|int(8..15) window_size)
Sets the encoding level, strategy and window_size.
Gz.deflate
int tell()
the current position within the file.
int write(string data)
Writes the data to the file.
the number of bytes written to the file.
The Bz2 module contains functions to compress and uncompress strings using the same algorithm as the program bzip2. Compressing and decompressing can be done in streaming mode feeding the compress and decompress objects with arbitrarily large pieces of data.
The Bz2 module consists of three classes; Bz2.Deflate,
Bz2.Inflate and Bz2.File. Bz2.Deflate is used to compress
data and Bz2.Inflate is used to uncompress data. Bz2.File is
used to handle Bzip2 files.
Note that this module is only available if libbzip2 was available when Pike was compiled.
Note that although the functions in Inflate and Deflate
use the same algorithm as bzip2, they do not use the
exact same format, so you can not directly zip files or unzip
zip-files using those functions. That is why there exists a
third class for files.
inherit "___Bz2" : Bz2
inherit Bz2::File : File
String.SplitIterator|Stdio.LineIterator line_iterator(int|void trim)
Returns an iterator that will loop over the lines in this file. If trim is true, all '\r' characters will be removed from the input.
function(:string) read_function(int nbytes)
Returns a function that when called will call read with
nbytes as argument. Can be used to get various callback
functions, eg for the fourth argument to
String.SplitIterator.
Implementation of the HPACK (RFC 7541) header packing standard.
This is the header packing system that is used in HTTP/2 (RFC 7540).
inherit "___HPack" : "___HPack"
constant int HPack.DEFAULT_HEADER_TABLE_SIZE
This is the default static maximum size of the dynamic header table.
This constant is taken from RFC 7540 section 6.5.2.
constant HPack.static_header_tab
Table of static headers. RFC 7541 appendix A, Table 1.
| Array | |||||||
|
| ||||||
Note that this table is indexed starting on 0 (zero),
while the corresponding table in RFC 7541 starts on 1
(one).
protected mapping(string(8bit):int|mapping(string(8bit):int)) HPack.static_header_index
Index for static_header_tab.
Note that the indices are offset by 1 (one).
This variable should be regarded as a constant.
This variable is used to initialize the header index in the Context.
static_header_tab, Context()->header_index
protected mapping(string(8bit):int|mapping(string(8bit):int)) create_index(array(array(string(8bit))) tab)
Helper function used to create the static_header_index.
protected void update_index(mapping(string(8bit):int|mapping(string(8bit):int)) index, int i, array(string(8bit)) key)
Update the specified encoder lookup index.
indexLookup index to add an entry to.
keyLookup key to add.
iValue to store in the index for the key.
Flags for Context()->encode_header() et al.
constant HPack.HEADER_INDEXED
Indexed header.
constant HPack.HEADER_INDEXED_MASK
Bitmask for indexing mode.
constant HPack.HEADER_NEVER_INDEXED
Never indexed header.
constant HPack.HEADER_NOT_INDEXED
Unindexed header.
Context for an HPack encoder or decoder.
This class implements the majority of RFC 7541.
Functions of interest are typically encode() and decode().
protected array(array(string(8bit))) HPack.Context.dynamic_headers
Table of currently available dynamically defined headers.
New entries are appended last, and the first dynamic_prefix
elements are not used.
header_index, add_header()
protected int HPack.Context.dynamic_max_size
Current upper size limit in bytes for dynamic_headers.
set_dynamic_size()
protected int HPack.Context.dynamic_prefix
Index of first avaiable header in dynamic_headers.
protected int HPack.Context.dynamic_size
Current size in bytes of dynamic_headers.
protected mapping(string(8bit):int|mapping(string(8bit):int)) HPack.Context.header_index
Index into dynamic_headers and static_header_tab.
| Indexed on the header name in lower-case. The value is one of:
|
The index values in turn are coded as follows:
| Index into |
| Not used. |
| Inverted ( |
dynamic_headers, static_header_tab, add_header()
protected int HPack.Context.static_max_size
Static upper size limit in bytes for dynamic_headers.
create(), set_dynamic_size()
int(0)|int(62) add_header(string(8bit) header, string(8bit) value)
Add a header to the table of known headers and to the header index.
headerName of header to add.
valueValue of the header.
Returns 0 (zero) if the header was too large to store.
Returns the encoding key for the header on success (this is always
sizeof(static_header_tab + 1 (ie 62), as new headers
are prepended to the dynamic header table.
Adding a header may cause old headers to be evicted from the table.
get_indexed_header()
HPack.Context HPack.Context(int|void protocol_dynamic_max_size)
Create a new HPack Context.
static_max_sizeThis is the static maximum size in bytes (as calculated by
RFC 7541 section 4.1) of the dynamic header table.
It defaults to DEFAULT_HEADER_TABLE_SIZE, and is the
upper limit for set_dynamic_size().
set_dynamic_size()
array(array(string(8bit)|HPackFlags)) decode(Stdio.Buffer buf)
Decode a HPack header block.
bufInput buffer.
Returns an array of headers. Cf decode_header().
decode_header(), encode()
array(string(8bit)|HPackFlags) decode_header(Stdio.Buffer buf)
Decode a single HPack header.
bufInput buffer.
Returns UNDEFINED on empty buffer.
Returns an array with a header and value otherwise:
| Array | |
| Name of the header. Under normal circumstances this is always lower-case, but no check is currently performed. |
| Value of the header. |
| Optional encoding flags. Only set for fields having
|
The elements in the array are in the same order and compatible
with the arguments to encode_header().
Throws on encoding errors.
The returned array MUST NOT be modified.
In future implementations the result array may get extended with a flag field.
The in-band signalling of encoding table sizes is handled internally.
decode(), encode_header()
void encode(array(array(string(8bit)|HPackFlags)) headers, Stdio.Buffer buf)
Encode a full set of headers.
headersAn array of ({ header, value })-tuples.
bufOutput buffer.
encode_header(), decode()
variant string(8bit) encode(array(array(string(8bit))) headers)
Convenience variant of encode().
headersAn array of ({ header, value })-tuples.
Returns the corresponding HPack encoding.
void encode_header(Stdio.Buffer buf, string(8bit) header, string(8bit) value, HPackFlags|void flags)
Encode a single HPack header.
bufOutput buffer.
headerName of header. This should under normal circumstances be a lower-case string, but this is currently not checked.
valueHeader value.
flagsOptional encoding flags.
encode(), decode_header()
protected void evict_dynamic_headers()
Evict dynamic headers until dynamic_size goes below
dynamic_max_size.
array(string(8bit)) get_indexed_header(int(1..) index)
Lookup a known header.
indexEncoding key for the header to retrieve.
Returns UNDEFINED on unknown header.
Returns an array with a header and value otherwise:
| Array | |
| Name of the header. Under normal circumstances this is always lower-case, but no check is currently performed. |
| Value of the header. |
add_header()
protected void put_int(Stdio.Buffer buf, int(8bit) bits, int(8bit) mask, int value)
Encode an integer with the HPack integer encoding.
bufOutput buffer.
bitsBits that should always be set in the first byte of output.
maskBitmask for the value part of the first byte of output.
valueInteger value to encode.
protected void put_string(Stdio.Buffer buf, string(8bit) str)
Encode a string with the HPack string encoding.
bufOutput buffer.
strString to output.
The encoder will huffman_encode() the string if that
renders a shorter encoding than the verbatim string.
void set_dynamic_size(Stdio.Buffer buf, int(0..) new_max_size)
Set the dynamic maximum size of the dynamic header lookup table.
bufOutput buffer.
new_max_sizeNew dynamic maximum size in bytes (as calculated by RFC 7541 section 4.1).
This function can be used to clear the dynamic header table by setting the size to zero.
Also note that the new_max_size has an upper bound that
is limited by static_max_size.
encode_header(), encode(), create().