mirror of
https://github.com/ibm-s390-linux/s390-tools.git
synced 2026-08-05 02:14:52 +00:00
1057f13cdc
Mainly zlib code remains unchanged for the sake of further maintenance. Only minor adjustments of zlib deflate parts for build purposes: - Make is_dfltcc_enabled() always return true - Define CONFIG_ZLIB_DFLTCC in zlib.h to build zlib code with DFLTCC support - Remove inflate related prototypes from zlib.h - Adjust oesc_msg() to use snprintf from libc.h - Remove BUG_ON from zlib_deflate_workspacesize() - Replace bitrev32() with bi_reverse() from defutil.h - Include <assert.h> to dfltcc.h header because of static_assert() calls - Fix other include statements - Adjust the text in zipl.h following Zlib License requirements Signed-off-by: Mikhail Zaslonko <zaslonko@linux.ibm.com> Reviewed-by: Alexander Egorenkov <egorenar@linux.ibm.com> Signed-off-by: Jan Höppner <hoeppner@linux.ibm.com>
386 lines
17 KiB
C
386 lines
17 KiB
C
/* zlib.h -- interface of the 'zlib' general purpose compression library
|
|
|
|
Copyright (C) 1995-2005 Jean-loup Gailly and Mark Adler
|
|
|
|
This software is provided 'as-is', without any express or implied
|
|
warranty. In no event will the authors be held liable for any damages
|
|
arising from the use of this software.
|
|
|
|
Permission is granted to anyone to use this software for any purpose,
|
|
including commercial applications, and to alter it and redistribute it
|
|
freely, subject to the following restrictions:
|
|
|
|
1. The origin of this software must not be misrepresented; you must not
|
|
claim that you wrote the original software. If you use this software
|
|
in a product, an acknowledgment in the product documentation would be
|
|
appreciated but is not required.
|
|
2. Altered source versions must be plainly marked as such, and must not be
|
|
misrepresented as being the original software.
|
|
3. This notice may not be removed or altered from any source distribution.
|
|
|
|
Jean-loup Gailly Mark Adler
|
|
jloup@gzip.org madler@alumni.caltech.edu
|
|
|
|
|
|
The data format used by the zlib library is described by RFCs (Request for
|
|
Comments) 1950 to 1952 in the files https://www.ietf.org/rfc/rfc1950.txt
|
|
(zlib format), rfc1951.txt (deflate format) and rfc1952.txt (gzip format).
|
|
*/
|
|
|
|
#ifndef _ZLIB_H
|
|
#define _ZLIB_H
|
|
|
|
#include "zconf.h"
|
|
|
|
/* Always build with DFLTCC support */
|
|
#define CONFIG_ZLIB_DFLTCC
|
|
|
|
/* zlib deflate based on ZLIB_VERSION "1.1.3" */
|
|
|
|
/*
|
|
This is a modified version of zlib for use inside s390-tools for dump
|
|
compression. It contains deflate parts only. Inflate code and function
|
|
prototypes are removed.
|
|
All memory allocations are to be performed in advance.
|
|
*/
|
|
|
|
/*
|
|
The 'zlib' compression library provides in-memory compression and
|
|
decompression functions, including integrity checks of the uncompressed
|
|
data. This version of the library supports only one compression method
|
|
(deflation) but other algorithms will be added later and will have the same
|
|
stream interface.
|
|
|
|
Compression can be done in a single step if the buffers are large
|
|
enough (for example if an input file is mmap'ed), or can be done by
|
|
repeated calls of the compression function. In the latter case, the
|
|
application must provide more input and/or consume the output
|
|
(providing more output space) before each call.
|
|
|
|
The compressed data format used by default by the in-memory functions is
|
|
the zlib format, which is a zlib wrapper documented in RFC 1950, wrapped
|
|
around a deflate stream, which is itself documented in RFC 1951.
|
|
|
|
The library also supports reading and writing files in gzip (.gz) format
|
|
with an interface similar to that of stdio.
|
|
|
|
The zlib format was designed to be compact and fast for use in memory
|
|
and on communications channels. The gzip format was designed for single-
|
|
file compression on file systems, has a larger header than zlib to maintain
|
|
directory information, and uses a different, slower check method than zlib.
|
|
|
|
The library does not install any signal handler. The decoder checks
|
|
the consistency of the compressed data, so the library should never
|
|
crash even in case of corrupted input.
|
|
*/
|
|
|
|
struct internal_state;
|
|
|
|
typedef struct z_stream_s {
|
|
const Byte *next_in; /* next input byte */
|
|
uLong avail_in; /* number of bytes available at next_in */
|
|
uLong total_in; /* total nb of input bytes read so far */
|
|
|
|
Byte *next_out; /* next output byte should be put there */
|
|
uLong avail_out; /* remaining free space at next_out */
|
|
uLong total_out; /* total nb of bytes output so far */
|
|
|
|
char *msg; /* last error message, NULL if no error */
|
|
struct internal_state *state; /* not visible by applications */
|
|
|
|
void *workspace; /* memory allocated for this stream */
|
|
|
|
int data_type; /* best guess about the data type: ascii or binary */
|
|
uLong adler; /* adler32 value of the uncompressed data */
|
|
uLong reserved; /* reserved for future use */
|
|
} z_stream;
|
|
|
|
typedef z_stream *z_streamp;
|
|
|
|
/*
|
|
The application must update next_in and avail_in when avail_in has
|
|
dropped to zero. It must update next_out and avail_out when avail_out
|
|
has dropped to zero. The application must initialize zalloc, zfree and
|
|
opaque before calling the init function. All other fields are set by the
|
|
compression library and must not be updated by the application.
|
|
|
|
The opaque value provided by the application will be passed as the first
|
|
parameter for calls of zalloc and zfree. This can be useful for custom
|
|
memory management. The compression library attaches no meaning to the
|
|
opaque value.
|
|
|
|
zalloc must return NULL if there is not enough memory for the object.
|
|
If zlib is used in a multi-threaded application, zalloc and zfree must be
|
|
thread safe.
|
|
|
|
On 16-bit systems, the functions zalloc and zfree must be able to allocate
|
|
exactly 65536 bytes, but will not be required to allocate more than this
|
|
if the symbol MAXSEG_64K is defined (see zconf.h). WARNING: On MSDOS,
|
|
pointers returned by zalloc for objects of exactly 65536 bytes *must*
|
|
have their offset normalized to zero. The default allocation function
|
|
provided by this library ensures this (see zutil.c). To reduce memory
|
|
requirements and avoid any allocation of 64K objects, at the expense of
|
|
compression ratio, compile the library with -DMAX_WBITS=14 (see zconf.h).
|
|
|
|
The fields total_in and total_out can be used for statistics or
|
|
progress reports. After compression, total_in holds the total size of
|
|
the uncompressed data and may be saved for use in the decompressor
|
|
(particularly if the decompressor wants to decompress everything in
|
|
a single step).
|
|
*/
|
|
|
|
/* constants */
|
|
|
|
#define Z_NO_FLUSH 0
|
|
#define Z_PARTIAL_FLUSH 1 /* will be removed, use Z_SYNC_FLUSH instead */
|
|
#define Z_PACKET_FLUSH 2
|
|
#define Z_SYNC_FLUSH 3
|
|
#define Z_FULL_FLUSH 4
|
|
#define Z_FINISH 5
|
|
#define Z_BLOCK 6 /* Only for inflate at present */
|
|
/* Allowed flush values; see deflate() and inflate() below for details */
|
|
|
|
#define Z_OK 0
|
|
#define Z_STREAM_END 1
|
|
#define Z_NEED_DICT 2
|
|
#define Z_ERRNO (-1)
|
|
#define Z_STREAM_ERROR (-2)
|
|
#define Z_DATA_ERROR (-3)
|
|
#define Z_MEM_ERROR (-4)
|
|
#define Z_BUF_ERROR (-5)
|
|
#define Z_VERSION_ERROR (-6)
|
|
/* Return codes for the compression/decompression functions. Negative
|
|
* values are errors, positive values are used for special but normal events.
|
|
*/
|
|
|
|
#define Z_NO_COMPRESSION 0
|
|
#define Z_BEST_SPEED 1
|
|
#define Z_BEST_COMPRESSION 9
|
|
#define Z_DEFAULT_COMPRESSION (-1)
|
|
/* compression levels */
|
|
|
|
#define Z_FILTERED 1
|
|
#define Z_HUFFMAN_ONLY 2
|
|
#define Z_DEFAULT_STRATEGY 0
|
|
/* compression strategy; see deflateInit2() below for details */
|
|
|
|
#define Z_BINARY 0
|
|
#define Z_ASCII 1
|
|
#define Z_UNKNOWN 2
|
|
/* Possible values of the data_type field */
|
|
|
|
#define Z_DEFLATED 8
|
|
/* The deflate compression method (the only one supported in this version) */
|
|
|
|
/* basic functions */
|
|
|
|
extern int zlib_deflate_workspacesize (int windowBits, int memLevel);
|
|
/*
|
|
Returns the number of bytes that needs to be allocated for a per-
|
|
stream workspace with the specified parameters. A pointer to this
|
|
number of bytes should be returned in stream->workspace before
|
|
you call zlib_deflateInit() or zlib_deflateInit2(). If you call
|
|
zlib_deflateInit(), specify windowBits = MAX_WBITS and memLevel =
|
|
MAX_MEM_LEVEL here. If you call zlib_deflateInit2(), the windowBits
|
|
and memLevel parameters passed to zlib_deflateInit2() must not
|
|
exceed those passed here.
|
|
*/
|
|
|
|
extern int zlib_deflate_dfltcc_enabled (void);
|
|
/*
|
|
Returns 1 if Deflate-Conversion facility is installed and enabled,
|
|
otherwise 0.
|
|
*/
|
|
|
|
/*
|
|
extern int deflateInit (z_streamp strm, int level);
|
|
|
|
Initializes the internal stream state for compression. The fields
|
|
zalloc, zfree and opaque must be initialized before by the caller.
|
|
If zalloc and zfree are set to NULL, deflateInit updates them to
|
|
use default allocation functions.
|
|
|
|
The compression level must be Z_DEFAULT_COMPRESSION, or between 0 and 9:
|
|
1 gives best speed, 9 gives best compression, 0 gives no compression at
|
|
all (the input data is simply copied a block at a time).
|
|
Z_DEFAULT_COMPRESSION requests a default compromise between speed and
|
|
compression (currently equivalent to level 6).
|
|
|
|
deflateInit returns Z_OK if success, Z_MEM_ERROR if there was not
|
|
enough memory, Z_STREAM_ERROR if level is not a valid compression level,
|
|
Z_VERSION_ERROR if the zlib library version (zlib_version) is incompatible
|
|
with the version assumed by the caller (ZLIB_VERSION).
|
|
msg is set to null if there is no error message. deflateInit does not
|
|
perform any compression: this will be done by deflate().
|
|
*/
|
|
|
|
|
|
extern int zlib_deflate (z_streamp strm, int flush);
|
|
/*
|
|
deflate compresses as much data as possible, and stops when the input
|
|
buffer becomes empty or the output buffer becomes full. It may introduce some
|
|
output latency (reading input without producing any output) except when
|
|
forced to flush.
|
|
|
|
The detailed semantics are as follows. deflate performs one or both of the
|
|
following actions:
|
|
|
|
- Compress more input starting at next_in and update next_in and avail_in
|
|
accordingly. If not all input can be processed (because there is not
|
|
enough room in the output buffer), next_in and avail_in are updated and
|
|
processing will resume at this point for the next call of deflate().
|
|
|
|
- Provide more output starting at next_out and update next_out and avail_out
|
|
accordingly. This action is forced if the parameter flush is non zero.
|
|
Forcing flush frequently degrades the compression ratio, so this parameter
|
|
should be set only when necessary (in interactive applications).
|
|
Some output may be provided even if flush is not set.
|
|
|
|
Before the call of deflate(), the application should ensure that at least
|
|
one of the actions is possible, by providing more input and/or consuming
|
|
more output, and updating avail_in or avail_out accordingly; avail_out
|
|
should never be zero before the call. The application can consume the
|
|
compressed output when it wants, for example when the output buffer is full
|
|
(avail_out == 0), or after each call of deflate(). If deflate returns Z_OK
|
|
and with zero avail_out, it must be called again after making room in the
|
|
output buffer because there might be more output pending.
|
|
|
|
If the parameter flush is set to Z_SYNC_FLUSH, all pending output is
|
|
flushed to the output buffer and the output is aligned on a byte boundary, so
|
|
that the decompressor can get all input data available so far. (In particular
|
|
avail_in is zero after the call if enough output space has been provided
|
|
before the call.) Flushing may degrade compression for some compression
|
|
algorithms and so it should be used only when necessary.
|
|
|
|
If flush is set to Z_FULL_FLUSH, all output is flushed as with
|
|
Z_SYNC_FLUSH, and the compression state is reset so that decompression can
|
|
restart from this point if previous compressed data has been damaged or if
|
|
random access is desired. Using Z_FULL_FLUSH too often can seriously degrade
|
|
the compression.
|
|
|
|
If deflate returns with avail_out == 0, this function must be called again
|
|
with the same value of the flush parameter and more output space (updated
|
|
avail_out), until the flush is complete (deflate returns with non-zero
|
|
avail_out).
|
|
|
|
If the parameter flush is set to Z_FINISH, pending input is processed,
|
|
pending output is flushed and deflate returns with Z_STREAM_END if there
|
|
was enough output space; if deflate returns with Z_OK, this function must be
|
|
called again with Z_FINISH and more output space (updated avail_out) but no
|
|
more input data, until it returns with Z_STREAM_END or an error. After
|
|
deflate has returned Z_STREAM_END, the only possible operations on the
|
|
stream are deflateReset or deflateEnd.
|
|
|
|
Z_FINISH can be used immediately after deflateInit if all the compression
|
|
is to be done in a single step. In this case, avail_out must be at least
|
|
0.1% larger than avail_in plus 12 bytes. If deflate does not return
|
|
Z_STREAM_END, then it must be called again as described above.
|
|
|
|
deflate() sets strm->adler to the adler32 checksum of all input read
|
|
so far (that is, total_in bytes).
|
|
|
|
deflate() may update data_type if it can make a good guess about
|
|
the input data type (Z_ASCII or Z_BINARY). In doubt, the data is considered
|
|
binary. This field is only for information purposes and does not affect
|
|
the compression algorithm in any manner.
|
|
|
|
deflate() returns Z_OK if some progress has been made (more input
|
|
processed or more output produced), Z_STREAM_END if all input has been
|
|
consumed and all output has been produced (only when flush is set to
|
|
Z_FINISH), Z_STREAM_ERROR if the stream state was inconsistent (for example
|
|
if next_in or next_out was NULL), Z_BUF_ERROR if no progress is possible
|
|
(for example avail_in or avail_out was zero).
|
|
*/
|
|
|
|
|
|
extern int zlib_deflateEnd (z_streamp strm);
|
|
/*
|
|
All dynamically allocated data structures for this stream are freed.
|
|
This function discards any unprocessed input and does not flush any
|
|
pending output.
|
|
|
|
deflateEnd returns Z_OK if success, Z_STREAM_ERROR if the
|
|
stream state was inconsistent, Z_DATA_ERROR if the stream was freed
|
|
prematurely (some input or output was discarded). In the error case,
|
|
msg may be set but then points to a static string (which must not be
|
|
deallocated).
|
|
*/
|
|
|
|
/* Advanced functions */
|
|
|
|
/*
|
|
The following functions are needed only in some special applications.
|
|
*/
|
|
|
|
/*
|
|
extern int deflateInit2 (z_streamp strm,
|
|
int level,
|
|
int method,
|
|
int windowBits,
|
|
int memLevel,
|
|
int strategy);
|
|
|
|
This is another version of deflateInit with more compression options. The
|
|
fields next_in, zalloc, zfree and opaque must be initialized before by
|
|
the caller.
|
|
|
|
The method parameter is the compression method. It must be Z_DEFLATED in
|
|
this version of the library.
|
|
|
|
The windowBits parameter is the base two logarithm of the window size
|
|
(the size of the history buffer). It should be in the range 8..15 for this
|
|
version of the library. Larger values of this parameter result in better
|
|
compression at the expense of memory usage. The default value is 15 if
|
|
deflateInit is used instead.
|
|
|
|
The memLevel parameter specifies how much memory should be allocated
|
|
for the internal compression state. memLevel=1 uses minimum memory but
|
|
is slow and reduces compression ratio; memLevel=9 uses maximum memory
|
|
for optimal speed. The default value is 8. See zconf.h for total memory
|
|
usage as a function of windowBits and memLevel.
|
|
|
|
The strategy parameter is used to tune the compression algorithm. Use the
|
|
value Z_DEFAULT_STRATEGY for normal data, Z_FILTERED for data produced by a
|
|
filter (or predictor), or Z_HUFFMAN_ONLY to force Huffman encoding only (no
|
|
string match). Filtered data consists mostly of small values with a
|
|
somewhat random distribution. In this case, the compression algorithm is
|
|
tuned to compress them better. The effect of Z_FILTERED is to force more
|
|
Huffman coding and less string matching; it is somewhat intermediate
|
|
between Z_DEFAULT and Z_HUFFMAN_ONLY. The strategy parameter only affects
|
|
the compression ratio but not the correctness of the compressed output even
|
|
if it is not set appropriately.
|
|
|
|
deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough
|
|
memory, Z_STREAM_ERROR if a parameter is invalid (such as an invalid
|
|
method). msg is set to null if there is no error message. deflateInit2 does
|
|
not perform any compression: this will be done by deflate().
|
|
*/
|
|
|
|
extern int zlib_deflateReset (z_streamp strm);
|
|
/*
|
|
This function is equivalent to deflateEnd followed by deflateInit,
|
|
but does not free and reallocate all the internal compression state.
|
|
The stream will keep the same compression level and any other attributes
|
|
that may have been set by deflateInit2.
|
|
|
|
deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source
|
|
stream state was inconsistent (such as zalloc or state being NULL).
|
|
*/
|
|
|
|
static inline unsigned long deflateBound(unsigned long s)
|
|
{
|
|
return s + ((s + 7) >> 3) + ((s + 63) >> 6) + 11;
|
|
}
|
|
|
|
#define zlib_deflateInit(strm, level) \
|
|
zlib_deflateInit2((strm), (level), Z_DEFLATED, MAX_WBITS, \
|
|
DEF_MEM_LEVEL, Z_DEFAULT_STRATEGY)
|
|
extern int zlib_deflateInit2(z_streamp strm, int level, int method,
|
|
int windowBits, int memLevel,
|
|
int strategy);
|
|
#if !defined(_Z_UTIL_H) && !defined(NO_DUMMY_DECL)
|
|
struct internal_state {int dummy;}; /* hack for buggy compilers */
|
|
#endif
|
|
|
|
#endif /* _ZLIB_H */
|