From 0faa9cfb3a9015ca723f012ca84609f602c7c03c Mon Sep 17 00:00:00 2001 From: Legonzaur <34353603+Legonzaur@users.noreply.github.com> Date: Wed, 16 Feb 2022 00:06:31 +0100 Subject: [PATCH] Compress previous logs and dump files on launch (#73) * added zlib + gzip Co-authored-by: Nathan TIEN YOU --- .../NorthstarDedicatedTest.vcxproj | 6 +- .../NorthstarDedicatedTest.vcxproj.filters | 6 + NorthstarDedicatedTest/include/zlib.h | 1912 +++++++++++++++++ NorthstarDedicatedTest/include/zlib.lib | Bin 0 -> 402696 bytes .../include/zlib/gzip/compress.hpp | 113 + .../include/zlib/gzip/config.hpp | 5 + .../include/zlib/gzip/version.hpp | 16 + NorthstarDedicatedTest/include/zlib/zconf.h | 534 +++++ NorthstarDedicatedTest/logCompression.cpp | 64 + NorthstarDedicatedTest/logCompression.h | 3 + NorthstarDedicatedTest/logging.cpp | 2 + 11 files changed, 2659 insertions(+), 2 deletions(-) create mode 100644 NorthstarDedicatedTest/include/zlib.h create mode 100644 NorthstarDedicatedTest/include/zlib.lib create mode 100644 NorthstarDedicatedTest/include/zlib/gzip/compress.hpp create mode 100644 NorthstarDedicatedTest/include/zlib/gzip/config.hpp create mode 100644 NorthstarDedicatedTest/include/zlib/gzip/version.hpp create mode 100644 NorthstarDedicatedTest/include/zlib/zconf.h create mode 100644 NorthstarDedicatedTest/logCompression.cpp create mode 100644 NorthstarDedicatedTest/logCompression.h diff --git a/NorthstarDedicatedTest/NorthstarDedicatedTest.vcxproj b/NorthstarDedicatedTest/NorthstarDedicatedTest.vcxproj index 9fa7e9df..afb2aa68 100644 --- a/NorthstarDedicatedTest/NorthstarDedicatedTest.vcxproj +++ b/NorthstarDedicatedTest/NorthstarDedicatedTest.vcxproj @@ -66,7 +66,7 @@ Windows true false - $(ProjectDir)include\MinHook.x64.lib;$(ProjectDir)include\libcurl\lib\libcurl_a.lib;dbghelp.lib;Wldap32.lib;Normaliz.lib;%(AdditionalDependencies) + $(ProjectDir)include\MinHook.x64.lib;$(ProjectDir)include\libcurl\lib\libcurl_a.lib;$(ProjectDir)include\zlib.lib;dbghelp.lib;Wldap32.lib;Normaliz.lib;%(AdditionalDependencies) %(AdditionalLibraryDirectories) @@ -96,7 +96,7 @@ true true false - $(ProjectDir)include\MinHook.x64.lib;$(ProjectDir)include\libcurl\lib\libcurl_a.lib;dbghelp.lib;Wldap32.lib;Normaliz.lib;%(AdditionalDependencies) + $(ProjectDir)include\zlib.lib;$(ProjectDir)include\MinHook.x64.lib;$(ProjectDir)include\libcurl\lib\libcurl_a.lib;dbghelp.lib;Wldap32.lib;Normaliz.lib;%(AdditionalDependencies) %(AdditionalLibraryDirectories) @@ -523,6 +523,7 @@ + @@ -569,6 +570,7 @@ + diff --git a/NorthstarDedicatedTest/NorthstarDedicatedTest.vcxproj.filters b/NorthstarDedicatedTest/NorthstarDedicatedTest.vcxproj.filters index 67679462..48103e89 100644 --- a/NorthstarDedicatedTest/NorthstarDedicatedTest.vcxproj.filters +++ b/NorthstarDedicatedTest/NorthstarDedicatedTest.vcxproj.filters @@ -1449,6 +1449,9 @@ Header Files\Client + + Header Files\Shared + @@ -1583,6 +1586,9 @@ Source Files\Client + + Source Files\Shared + diff --git a/NorthstarDedicatedTest/include/zlib.h b/NorthstarDedicatedTest/include/zlib.h new file mode 100644 index 00000000..35808a90 --- /dev/null +++ b/NorthstarDedicatedTest/include/zlib.h @@ -0,0 +1,1912 @@ +/* zlib.h -- interface of the 'zlib' general purpose compression library + version 1.2.11, January 15th, 2017 + + Copyright (C) 1995-2017 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 http://tools.ietf.org/html/rfc1950 + (zlib format), rfc1951 (deflate format) and rfc1952 (gzip format). +*/ + +#ifndef ZLIB_H +#define ZLIB_H + +#include "zlib/zconf.h" + +#ifdef __cplusplus +extern "C" { +#endif + +#define ZLIB_VERSION "1.2.11" +#define ZLIB_VERNUM 0x12b0 +#define ZLIB_VER_MAJOR 1 +#define ZLIB_VER_MINOR 2 +#define ZLIB_VER_REVISION 11 +#define ZLIB_VER_SUBREVISION 0 + +/* + 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, + 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 using the functions that start + with "gz". The gzip format is different from the zlib format. gzip is a + gzip wrapper, documented in RFC 1952, wrapped around a deflate stream. + + This library can optionally read and write gzip and raw deflate streams in + memory as well. + + 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 the case of corrupted input. +*/ + +typedef voidpf (*alloc_func) OF((voidpf opaque, uInt items, uInt size)); +typedef void (*free_func) OF((voidpf opaque, voidpf address)); + +struct internal_state; + +typedef struct z_stream_s { + z_const Bytef *next_in; /* next input byte */ + uInt avail_in; /* number of bytes available at next_in */ + uLong total_in; /* total number of input bytes read so far */ + + Bytef *next_out; /* next output byte will go here */ + uInt avail_out; /* remaining free space at next_out */ + uLong total_out; /* total number of bytes output so far */ + + z_const char *msg; /* last error message, NULL if no error */ + struct internal_state FAR *state; /* not visible by applications */ + + alloc_func zalloc; /* used to allocate the internal state */ + free_func zfree; /* used to free the internal state */ + voidpf opaque; /* private data object passed to zalloc and zfree */ + + int data_type; /* best guess about the data type: binary or text + for deflate, or the decoding state for inflate */ + uLong adler; /* Adler-32 or CRC-32 value of the uncompressed data */ + uLong reserved; /* reserved for future use */ +} z_stream; + +typedef z_stream FAR *z_streamp; + +/* + gzip header information passed to and from zlib routines. See RFC 1952 + for more details on the meanings of these fields. +*/ +typedef struct gz_header_s { + int text; /* true if compressed data believed to be text */ + uLong time; /* modification time */ + int xflags; /* extra flags (not used when writing a gzip file) */ + int os; /* operating system */ + Bytef *extra; /* pointer to extra field or Z_NULL if none */ + uInt extra_len; /* extra field length (valid if extra != Z_NULL) */ + uInt extra_max; /* space at extra (only when reading header) */ + Bytef *name; /* pointer to zero-terminated file name or Z_NULL */ + uInt name_max; /* space at name (only when reading header) */ + Bytef *comment; /* pointer to zero-terminated comment or Z_NULL */ + uInt comm_max; /* space at comment (only when reading header) */ + int hcrc; /* true if there was or will be a header crc */ + int done; /* true when done reading gzip header (not used + when writing a gzip file) */ +} gz_header; + +typedef gz_header FAR *gz_headerp; + +/* + 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 Z_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. In that case, zlib is thread-safe. When zalloc and zfree are + Z_NULL on entry to the initialization function, they are set to internal + routines that use the standard library functions malloc() and free(). + + 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 by 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 +#define Z_SYNC_FLUSH 2 +#define Z_FULL_FLUSH 3 +#define Z_FINISH 4 +#define Z_BLOCK 5 +#define Z_TREES 6 +/* 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_RLE 3 +#define Z_FIXED 4 +#define Z_DEFAULT_STRATEGY 0 +/* compression strategy; see deflateInit2() below for details */ + +#define Z_BINARY 0 +#define Z_TEXT 1 +#define Z_ASCII Z_TEXT /* for compatibility with 1.2.2 and earlier */ +#define Z_UNKNOWN 2 +/* Possible values of the data_type field for deflate() */ + +#define Z_DEFLATED 8 +/* The deflate compression method (the only one supported in this version) */ + +#define Z_NULL 0 /* for initializing zalloc, zfree, opaque */ + +#define zlib_version zlibVersion() +/* for compatibility with versions < 1.0.2 */ + + + /* basic functions */ + +ZEXTERN const char * ZEXPORT zlibVersion OF((void)); +/* The application can compare zlibVersion and ZLIB_VERSION for consistency. + If the first character differs, the library code actually used is not + compatible with the zlib.h header file used by the application. This check + is automatically made by deflateInit and inflateInit. + */ + +/* +ZEXTERN int ZEXPORT deflateInit OF((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 Z_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, or + 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(). +*/ + + +ZEXTERN int ZEXPORT deflate OF((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(). + + - Generate 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. Some output may be provided even if + flush is zero. + + 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. See deflatePending(), + which can be used if desired to determine whether or not there is more ouput + in that case. + + Normally the parameter flush is set to Z_NO_FLUSH, which allows deflate to + decide how much data to accumulate before producing output, in order to + maximize compression. + + 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. This + completes the current deflate block and follows it with an empty stored block + that is three bits plus filler bits to the next byte, followed by four bytes + (00 00 ff ff). + + If flush is set to Z_PARTIAL_FLUSH, all pending output is flushed to the + output buffer, but the output is not aligned to a byte boundary. All of the + input data so far will be available to the decompressor, as for Z_SYNC_FLUSH. + This completes the current deflate block and follows it with an empty fixed + codes block that is 10 bits long. This assures that enough bytes are output + in order for the decompressor to finish the block before the empty fixed + codes block. + + If flush is set to Z_BLOCK, a deflate block is completed and emitted, as + for Z_SYNC_FLUSH, but the output is not aligned on a byte boundary, and up to + seven bits of the current block are held to be written as the next byte after + the next deflate block is completed. In this case, the decompressor may not + be provided enough bits at this point in order to complete decompression of + the data provided so far to the compressor. It may need to wait for the next + block to be emitted. This is for advanced applications that need to control + the emission of deflate blocks. + + 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 + 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). In the case of a Z_FULL_FLUSH or Z_SYNC_FLUSH, make sure that + avail_out is greater than six to avoid repeated flush markers due to + avail_out == 0 on return. + + 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 or Z_BUF_ERROR, 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 in the first deflate call after deflateInit if all the + compression is to be done in a single step. In order to complete in one + call, avail_out must be at least the value returned by deflateBound (see + below). Then deflate is guaranteed to return Z_STREAM_END. If not enough + output space is provided, deflate will not return Z_STREAM_END, and it must + be called again as described above. + + deflate() sets strm->adler to the Adler-32 checksum of all input read + so far (that is, total_in bytes). If a gzip stream is being generated, then + strm->adler will be the CRC-32 checksum of the input read so far. (See + deflateInit2 below.) + + deflate() may update strm->data_type if it can make a good guess about + the input data type (Z_BINARY or Z_TEXT). If 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 Z_NULL or the state was inadvertently written over + by the application), or Z_BUF_ERROR if no progress is possible (for example + avail_in or avail_out was zero). Note that Z_BUF_ERROR is not fatal, and + deflate() can be called again with more input and more output space to + continue compressing. +*/ + + +ZEXTERN int ZEXPORT deflateEnd OF((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). +*/ + + +/* +ZEXTERN int ZEXPORT inflateInit OF((z_streamp strm)); + + Initializes the internal stream state for decompression. The fields + next_in, avail_in, zalloc, zfree and opaque must be initialized before by + the caller. In the current version of inflate, the provided input is not + read or consumed. The allocation of a sliding window will be deferred to + the first call of inflate (if the decompression does not complete on the + first call). If zalloc and zfree are set to Z_NULL, inflateInit updates + them to use default allocation functions. + + inflateInit returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit does not perform any decompression. + Actual decompression will be done by inflate(). So next_in, and avail_in, + next_out, and avail_out are unused and unchanged. The current + implementation of inflateInit() does not process any header information -- + that is deferred until inflate() is called. +*/ + + +ZEXTERN int ZEXPORT inflate OF((z_streamp strm, int flush)); +/* + inflate decompresses 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. inflate performs one or both of the + following actions: + + - Decompress 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), then next_in and avail_in are updated + accordingly, and processing will resume at this point for the next call of + inflate(). + + - Generate more output starting at next_out and update next_out and avail_out + accordingly. inflate() provides as much output as possible, until there is + no more input data or no more space in the output buffer (see below about + the flush parameter). + + Before the call of inflate(), the application should ensure that at least + one of the actions is possible, by providing more input and/or consuming more + output, and updating the next_* and avail_* values accordingly. If the + caller of inflate() does not provide both available input and available + output space, it is possible that there will be no progress made. The + application can consume the uncompressed output when it wants, for example + when the output buffer is full (avail_out == 0), or after each call of + inflate(). If inflate 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. + + The flush parameter of inflate() can be Z_NO_FLUSH, Z_SYNC_FLUSH, Z_FINISH, + Z_BLOCK, or Z_TREES. Z_SYNC_FLUSH requests that inflate() flush as much + output as possible to the output buffer. Z_BLOCK requests that inflate() + stop if and when it gets to the next deflate block boundary. When decoding + the zlib or gzip format, this will cause inflate() to return immediately + after the header and before the first block. When doing a raw inflate, + inflate() will go ahead and process the first block, and will return when it + gets to the end of that block, or when it runs out of data. + + The Z_BLOCK option assists in appending to or combining deflate streams. + To assist in this, on return inflate() always sets strm->data_type to the + number of unused bits in the last byte taken from strm->next_in, plus 64 if + inflate() is currently decoding the last block in the deflate stream, plus + 128 if inflate() returned immediately after decoding an end-of-block code or + decoding the complete header up to just before the first byte of the deflate + stream. The end-of-block will not be indicated until all of the uncompressed + data from that block has been written to strm->next_out. The number of + unused bits may in general be greater than seven, except when bit 7 of + data_type is set, in which case the number of unused bits will be less than + eight. data_type is set as noted here every time inflate() returns for all + flush options, and so can be used to determine the amount of currently + consumed input in bits. + + The Z_TREES option behaves as Z_BLOCK does, but it also returns when the + end of each deflate block header is reached, before any actual data in that + block is decoded. This allows the caller to determine the length of the + deflate block header for later use in random access within a deflate block. + 256 is added to the value of strm->data_type when inflate() returns + immediately after reaching the end of the deflate block header. + + inflate() should normally be called until it returns Z_STREAM_END or an + error. However if all decompression is to be performed in a single step (a + single call of inflate), the parameter flush should be set to Z_FINISH. In + this case all pending input is processed and all pending output is flushed; + avail_out must be large enough to hold all of the uncompressed data for the + operation to complete. (The size of the uncompressed data may have been + saved by the compressor for this purpose.) The use of Z_FINISH is not + required to perform an inflation in one step. However it may be used to + inform inflate that a faster approach can be used for the single inflate() + call. Z_FINISH also informs inflate to not maintain a sliding window if the + stream completes, which reduces inflate's memory footprint. If the stream + does not complete, either because not all of the stream is provided or not + enough output space is provided, then a sliding window will be allocated and + inflate() can be called again to continue the operation as if Z_NO_FLUSH had + been used. + + In this implementation, inflate() always flushes as much output as + possible to the output buffer, and always uses the faster approach on the + first call. So the effects of the flush parameter in this implementation are + on the return value of inflate() as noted below, when inflate() returns early + when Z_BLOCK or Z_TREES is used, and when inflate() avoids the allocation of + memory for a sliding window when Z_FINISH is used. + + If a preset dictionary is needed after this call (see inflateSetDictionary + below), inflate sets strm->adler to the Adler-32 checksum of the dictionary + chosen by the compressor and returns Z_NEED_DICT; otherwise it sets + strm->adler to the Adler-32 checksum of all output produced so far (that is, + total_out bytes) and returns Z_OK, Z_STREAM_END or an error code as described + below. At the end of the stream, inflate() checks that its computed Adler-32 + checksum is equal to that saved by the compressor and returns Z_STREAM_END + only if the checksum is correct. + + inflate() can decompress and check either zlib-wrapped or gzip-wrapped + deflate data. The header type is detected automatically, if requested when + initializing with inflateInit2(). Any information contained in the gzip + header is not retained unless inflateGetHeader() is used. When processing + gzip-wrapped deflate data, strm->adler32 is set to the CRC-32 of the output + produced so far. The CRC-32 is checked against the gzip trailer, as is the + uncompressed length, modulo 2^32. + + inflate() returns Z_OK if some progress has been made (more input processed + or more output produced), Z_STREAM_END if the end of the compressed data has + been reached and all uncompressed output has been produced, Z_NEED_DICT if a + preset dictionary is needed at this point, Z_DATA_ERROR if the input data was + corrupted (input stream not conforming to the zlib format or incorrect check + value, in which case strm->msg points to a string with a more specific + error), Z_STREAM_ERROR if the stream structure was inconsistent (for example + next_in or next_out was Z_NULL, or the state was inadvertently written over + by the application), Z_MEM_ERROR if there was not enough memory, Z_BUF_ERROR + if no progress was possible or if there was not enough room in the output + buffer when Z_FINISH is used. Note that Z_BUF_ERROR is not fatal, and + inflate() can be called again with more input and more output space to + continue decompressing. If Z_DATA_ERROR is returned, the application may + then call inflateSync() to look for a good compression block if a partial + recovery of the data is to be attempted. +*/ + + +ZEXTERN int ZEXPORT inflateEnd OF((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. + + inflateEnd returns Z_OK if success, or Z_STREAM_ERROR if the stream state + was inconsistent. +*/ + + + /* Advanced functions */ + +/* + The following functions are needed only in some special applications. +*/ + +/* +ZEXTERN int ZEXPORT deflateInit2 OF((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. + + For the current implementation of deflate(), a windowBits value of 8 (a + window size of 256 bytes) is not supported. As a result, a request for 8 + will result in 9 (a 512-byte window). In that case, providing 8 to + inflateInit2() will result in an error when the zlib header with 9 is + checked against the initialization of inflate(). The remedy is to not use 8 + with deflateInit2() with this initialization, or at least in that case use 9 + with inflateInit2(). + + windowBits can also be -8..-15 for raw deflate. In this case, -windowBits + determines the window size. deflate() will then generate raw deflate data + with no zlib header or trailer, and will not compute a check value. + + windowBits can also be greater than 15 for optional gzip encoding. Add + 16 to windowBits to write a simple gzip header and trailer around the + compressed data instead of a zlib wrapper. The gzip header will have no + file name, no extra data, no comment, no modification time (set to zero), no + header crc, and the operating system will be set to the appropriate value, + if the operating system was determined at compile time. If a gzip stream is + being written, strm->adler is a CRC-32 instead of an Adler-32. + + For raw deflate or gzip encoding, a request for a 256-byte window is + rejected as invalid, since only the zlib header provides a means of + transmitting the window size to the decompressor. + + 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), Z_HUFFMAN_ONLY to force Huffman encoding only (no + string match), or Z_RLE to limit match distances to one (run-length + encoding). 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_STRATEGY and Z_HUFFMAN_ONLY. Z_RLE is designed to be almost as + fast as Z_HUFFMAN_ONLY, but give better compression for PNG image data. The + strategy parameter only affects the compression ratio but not the + correctness of the compressed output even if it is not set appropriately. + Z_FIXED prevents the use of dynamic Huffman codes, allowing for a simpler + decoder for special applications. + + deflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_STREAM_ERROR if any parameter is invalid (such as an invalid + method), or 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. deflateInit2 does not perform any + compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the compression dictionary from the given byte sequence + without producing any compressed output. When using the zlib format, this + function must be called immediately after deflateInit, deflateInit2 or + deflateReset, and before any call of deflate. When doing raw deflate, this + function must be called either before any call of deflate, or immediately + after the completion of a deflate block, i.e. after all input has been + consumed and all output has been delivered when using any of the flush + options Z_BLOCK, Z_PARTIAL_FLUSH, Z_SYNC_FLUSH, or Z_FULL_FLUSH. The + compressor and decompressor must use exactly the same dictionary (see + inflateSetDictionary). + + The dictionary should consist of strings (byte sequences) that are likely + to be encountered later in the data to be compressed, with the most commonly + used strings preferably put towards the end of the dictionary. Using a + dictionary is most useful when the data to be compressed is short and can be + predicted with good accuracy; the data can then be compressed better than + with the default empty dictionary. + + Depending on the size of the compression data structures selected by + deflateInit or deflateInit2, a part of the dictionary may in effect be + discarded, for example if the dictionary is larger than the window size + provided in deflateInit or deflateInit2. Thus the strings most likely to be + useful should be put at the end of the dictionary, not at the front. In + addition, the current implementation of deflate will use at most the window + size minus 262 bytes of the provided dictionary. + + Upon return of this function, strm->adler is set to the Adler-32 value + of the dictionary; the decompressor may later use this value to determine + which dictionary has been used by the compressor. (The Adler-32 value + applies to the whole dictionary even if only a subset of the dictionary is + actually used by the compressor.) If a raw deflate was requested, then the + Adler-32 value is not computed and strm->adler is not set. + + deflateSetDictionary returns Z_OK if success, or Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is + inconsistent (for example if deflate has already been called for this stream + or if not at a block boundary for raw deflate). deflateSetDictionary does + not perform any compression: this will be done by deflate(). +*/ + +ZEXTERN int ZEXPORT deflateGetDictionary OF((z_streamp strm, + Bytef *dictionary, + uInt *dictLength)); +/* + Returns the sliding dictionary being maintained by deflate. dictLength is + set to the number of bytes in the dictionary, and that many bytes are copied + to dictionary. dictionary must have enough space, where 32768 bytes is + always enough. If deflateGetDictionary() is called with dictionary equal to + Z_NULL, then only the dictionary length is returned, and nothing is copied. + Similary, if dictLength is Z_NULL, then it is not set. + + deflateGetDictionary() may return a length less than the window size, even + when more than the window size in input has been provided. It may return up + to 258 bytes less in that case, due to how zlib's implementation of deflate + manages the sliding window and lookahead for matches, where matches can be + up to 258 bytes long. If the application needs the last window-size bytes of + input, then that would need to be saved by the application outside of zlib. + + deflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the + stream state is inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when several compression strategies will be + tried, for example when there are several ways of pre-processing the input + data with a filter. The streams that will be discarded should then be freed + by calling deflateEnd. Note that deflateCopy duplicates the internal + compression state which can be quite large, so this strategy is slow and can + consume lots of memory. + + deflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT deflateReset OF((z_streamp strm)); +/* + This function is equivalent to deflateEnd followed by deflateInit, but + does not free and reallocate the internal compression state. The stream + will leave the compression level and any other attributes that may have been + set unchanged. + + deflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT deflateParams OF((z_streamp strm, + int level, + int strategy)); +/* + Dynamically update the compression level and compression strategy. The + interpretation of level and strategy is as in deflateInit2(). This can be + used to switch between compression and straight copy of the input data, or + to switch to a different kind of input data requiring a different strategy. + If the compression approach (which is a function of the level) or the + strategy is changed, and if any input has been consumed in a previous + deflate() call, then the input available so far is compressed with the old + level and strategy using deflate(strm, Z_BLOCK). There are three approaches + for the compression levels 0, 1..3, and 4..9 respectively. The new level + and strategy will take effect at the next call of deflate(). + + If a deflate(strm, Z_BLOCK) is performed by deflateParams(), and it does + not have enough output space to complete, then the parameter change will not + take effect. In this case, deflateParams() can be called again with the + same parameters and more output space to try again. + + In order to assure a change in the parameters on the first try, the + deflate stream should be flushed using deflate() with Z_BLOCK or other flush + request until strm.avail_out is not zero, before calling deflateParams(). + Then no more input data should be provided before the deflateParams() call. + If this is done, the old level and strategy will be applied to the data + compressed before deflateParams(), and the new level and strategy will be + applied to the the data compressed after deflateParams(). + + deflateParams returns Z_OK on success, Z_STREAM_ERROR if the source stream + state was inconsistent or if a parameter was invalid, or Z_BUF_ERROR if + there was not enough output space to complete the compression of the + available input data before a change in the strategy or approach. Note that + in the case of a Z_BUF_ERROR, the parameters are not changed. A return + value of Z_BUF_ERROR is not fatal, in which case deflateParams() can be + retried with more output space. +*/ + +ZEXTERN int ZEXPORT deflateTune OF((z_streamp strm, + int good_length, + int max_lazy, + int nice_length, + int max_chain)); +/* + Fine tune deflate's internal compression parameters. This should only be + used by someone who understands the algorithm used by zlib's deflate for + searching for the best matching string, and even then only by the most + fanatic optimizer trying to squeeze out the last compressed bit for their + specific input data. Read the deflate.c source code for the meaning of the + max_lazy, good_length, nice_length, and max_chain parameters. + + deflateTune() can be called after deflateInit() or deflateInit2(), and + returns Z_OK on success, or Z_STREAM_ERROR for an invalid deflate stream. + */ + +ZEXTERN uLong ZEXPORT deflateBound OF((z_streamp strm, + uLong sourceLen)); +/* + deflateBound() returns an upper bound on the compressed size after + deflation of sourceLen bytes. It must be called after deflateInit() or + deflateInit2(), and after deflateSetHeader(), if used. This would be used + to allocate an output buffer for deflation in a single pass, and so would be + called before deflate(). If that first deflate() call is provided the + sourceLen input bytes, an output buffer allocated to the size returned by + deflateBound(), and the flush value Z_FINISH, then deflate() is guaranteed + to return Z_STREAM_END. Note that it is possible for the compressed size to + be larger than the value returned by deflateBound() if flush options other + than Z_FINISH or Z_NO_FLUSH are used. +*/ + +ZEXTERN int ZEXPORT deflatePending OF((z_streamp strm, + unsigned *pending, + int *bits)); +/* + deflatePending() returns the number of bytes and bits of output that have + been generated, but not yet provided in the available output. The bytes not + provided would be due to the available output space having being consumed. + The number of bits of output not provided are between 0 and 7, where they + await more bits to join them in order to fill out a full byte. If pending + or bits are Z_NULL, then those values are not set. + + deflatePending returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. + */ + +ZEXTERN int ZEXPORT deflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + deflatePrime() inserts bits in the deflate output stream. The intent + is that this function is used to start off the deflate output with the bits + leftover from a previous deflate stream when appending to it. As such, this + function can only be used for raw deflate, and must be used before the first + deflate() call after a deflateInit2() or deflateReset(). bits must be less + than or equal to 16, and that many of the least significant bits of value + will be inserted in the output. + + deflatePrime returns Z_OK if success, Z_BUF_ERROR if there was not enough + room in the internal buffer to insert the bits, or Z_STREAM_ERROR if the + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT deflateSetHeader OF((z_streamp strm, + gz_headerp head)); +/* + deflateSetHeader() provides gzip header information for when a gzip + stream is requested by deflateInit2(). deflateSetHeader() may be called + after deflateInit2() or deflateReset() and before the first call of + deflate(). The text, time, os, extra field, name, and comment information + in the provided gz_header structure are written to the gzip header (xflag is + ignored -- the extra flags are set according to the compression level). The + caller must assure that, if not Z_NULL, name and comment are terminated with + a zero byte, and that if extra is not Z_NULL, that extra_len bytes are + available there. If hcrc is true, a gzip header crc is included. Note that + the current versions of the command-line version of gzip (up through version + 1.3.x) do not support header crc's, and will report that it is a "multi-part + gzip file" and give up. + + If deflateSetHeader is not used, the default gzip header has text false, + the time set to zero, and os set to 255, with no extra, name, or comment + fields. The gzip header is returned to the default state by deflateReset(). + + deflateSetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateInit2 OF((z_streamp strm, + int windowBits)); + + This is another version of inflateInit with an extra parameter. The + fields next_in, avail_in, zalloc, zfree and opaque must be initialized + before by the caller. + + The windowBits parameter is the base two logarithm of the maximum window + size (the size of the history buffer). It should be in the range 8..15 for + this version of the library. The default value is 15 if inflateInit is used + instead. windowBits must be greater than or equal to the windowBits value + provided to deflateInit2() while compressing, or it must be equal to 15 if + deflateInit2() was not used. If a compressed stream with a larger window + size is given as input, inflate() will return with the error code + Z_DATA_ERROR instead of trying to allocate a larger window. + + windowBits can also be zero to request that inflate use the window size in + the zlib header of the compressed stream. + + windowBits can also be -8..-15 for raw inflate. In this case, -windowBits + determines the window size. inflate() will then process raw deflate data, + not looking for a zlib or gzip header, not generating a check value, and not + looking for any check values for comparison at the end of the stream. This + is for use with other formats that use the deflate compressed data format + such as zip. Those formats provide their own check values. If a custom + format is developed using the raw deflate format for compressed data, it is + recommended that a check value such as an Adler-32 or a CRC-32 be applied to + the uncompressed data as is done in the zlib, gzip, and zip formats. For + most applications, the zlib format should be used as is. Note that comments + above on the use in deflateInit2() applies to the magnitude of windowBits. + + windowBits can also be greater than 15 for optional gzip decoding. Add + 32 to windowBits to enable zlib and gzip decoding with automatic header + detection, or add 16 to decode only the gzip format (the zlib format will + return a Z_DATA_ERROR). If a gzip stream is being decoded, strm->adler is a + CRC-32 instead of an Adler-32. Unlike the gunzip utility and gzread() (see + below), inflate() will not automatically decode concatenated gzip streams. + inflate() will return Z_STREAM_END at the end of the gzip stream. The state + would need to be reset to continue decoding a subsequent gzip stream. + + inflateInit2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_VERSION_ERROR if the zlib library version is incompatible with the + version assumed by the caller, or Z_STREAM_ERROR if the parameters are + invalid, such as a null pointer to the structure. msg is set to null if + there is no error message. inflateInit2 does not perform any decompression + apart from possibly reading the zlib header if present: actual decompression + will be done by inflate(). (So next_in and avail_in may be modified, but + next_out and avail_out are unused and unchanged.) The current implementation + of inflateInit2() does not process any header information -- that is + deferred until inflate() is called. +*/ + +ZEXTERN int ZEXPORT inflateSetDictionary OF((z_streamp strm, + const Bytef *dictionary, + uInt dictLength)); +/* + Initializes the decompression dictionary from the given uncompressed byte + sequence. This function must be called immediately after a call of inflate, + if that call returned Z_NEED_DICT. The dictionary chosen by the compressor + can be determined from the Adler-32 value returned by that call of inflate. + The compressor and decompressor must use exactly the same dictionary (see + deflateSetDictionary). For raw inflate, this function can be called at any + time to set the dictionary. If the provided dictionary is smaller than the + window and there is already data in the window, then the provided dictionary + will amend what's there. The application must insure that the dictionary + that was used for compression is provided. + + inflateSetDictionary returns Z_OK if success, Z_STREAM_ERROR if a + parameter is invalid (e.g. dictionary being Z_NULL) or the stream state is + inconsistent, Z_DATA_ERROR if the given dictionary doesn't match the + expected one (incorrect Adler-32 value). inflateSetDictionary does not + perform any decompression: this will be done by subsequent calls of + inflate(). +*/ + +ZEXTERN int ZEXPORT inflateGetDictionary OF((z_streamp strm, + Bytef *dictionary, + uInt *dictLength)); +/* + Returns the sliding dictionary being maintained by inflate. dictLength is + set to the number of bytes in the dictionary, and that many bytes are copied + to dictionary. dictionary must have enough space, where 32768 bytes is + always enough. If inflateGetDictionary() is called with dictionary equal to + Z_NULL, then only the dictionary length is returned, and nothing is copied. + Similary, if dictLength is Z_NULL, then it is not set. + + inflateGetDictionary returns Z_OK on success, or Z_STREAM_ERROR if the + stream state is inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateSync OF((z_streamp strm)); +/* + Skips invalid compressed data until a possible full flush point (see above + for the description of deflate with Z_FULL_FLUSH) can be found, or until all + available input is skipped. No output is provided. + + inflateSync searches for a 00 00 FF FF pattern in the compressed data. + All full flush points have this pattern, but not all occurrences of this + pattern are full flush points. + + inflateSync returns Z_OK if a possible full flush point has been found, + Z_BUF_ERROR if no more input was provided, Z_DATA_ERROR if no flush point + has been found, or Z_STREAM_ERROR if the stream structure was inconsistent. + In the success case, the application may save the current current value of + total_in which indicates where valid compressed data was found. In the + error case, the application may repeatedly call inflateSync, providing more + input each time, until success or end of the input data. +*/ + +ZEXTERN int ZEXPORT inflateCopy OF((z_streamp dest, + z_streamp source)); +/* + Sets the destination stream as a complete copy of the source stream. + + This function can be useful when randomly accessing a large stream. The + first pass through the stream can periodically record the inflate state, + allowing restarting inflate at those points when randomly accessing the + stream. + + inflateCopy returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_STREAM_ERROR if the source stream state was inconsistent + (such as zalloc being Z_NULL). msg is left unchanged in both source and + destination. +*/ + +ZEXTERN int ZEXPORT inflateReset OF((z_streamp strm)); +/* + This function is equivalent to inflateEnd followed by inflateInit, + but does not free and reallocate the internal decompression state. The + stream will keep attributes that may have been set by inflateInit2. + + inflateReset returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL). +*/ + +ZEXTERN int ZEXPORT inflateReset2 OF((z_streamp strm, + int windowBits)); +/* + This function is the same as inflateReset, but it also permits changing + the wrap and window size requests. The windowBits parameter is interpreted + the same as it is for inflateInit2. If the window size is changed, then the + memory allocated for the window is freed, and the window will be reallocated + by inflate() if needed. + + inflateReset2 returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent (such as zalloc or state being Z_NULL), or if + the windowBits parameter is invalid. +*/ + +ZEXTERN int ZEXPORT inflatePrime OF((z_streamp strm, + int bits, + int value)); +/* + This function inserts bits in the inflate input stream. The intent is + that this function is used to start inflating at a bit position in the + middle of a byte. The provided bits will be used before any bytes are used + from next_in. This function should only be used with raw inflate, and + should be used before the first inflate() call after inflateInit2() or + inflateReset(). bits must be less than or equal to 16, and that many of the + least significant bits of value will be inserted in the input. + + If bits is negative, then the input stream bit buffer is emptied. Then + inflatePrime() can be called again to put bits in the buffer. This is used + to clear out bits leftover after feeding inflate a block description prior + to feeding inflate codes. + + inflatePrime returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +ZEXTERN long ZEXPORT inflateMark OF((z_streamp strm)); +/* + This function returns two values, one in the lower 16 bits of the return + value, and the other in the remaining upper bits, obtained by shifting the + return value down 16 bits. If the upper value is -1 and the lower value is + zero, then inflate() is currently decoding information outside of a block. + If the upper value is -1 and the lower value is non-zero, then inflate is in + the middle of a stored block, with the lower value equaling the number of + bytes from the input remaining to copy. If the upper value is not -1, then + it is the number of bits back from the current bit position in the input of + the code (literal or length/distance pair) currently being processed. In + that case the lower value is the number of bytes already emitted for that + code. + + A code is being processed if inflate is waiting for more input to complete + decoding of the code, or if it has completed decoding but is waiting for + more output space to write the literal or match data. + + inflateMark() is used to mark locations in the input data for random + access, which may be at bit positions, and to note those cases where the + output of a code may span boundaries of random access blocks. The current + location in the input stream can be determined from avail_in and data_type + as noted in the description for the Z_BLOCK flush parameter for inflate. + + inflateMark returns the value noted above, or -65536 if the provided + source stream state was inconsistent. +*/ + +ZEXTERN int ZEXPORT inflateGetHeader OF((z_streamp strm, + gz_headerp head)); +/* + inflateGetHeader() requests that gzip header information be stored in the + provided gz_header structure. inflateGetHeader() may be called after + inflateInit2() or inflateReset(), and before the first call of inflate(). + As inflate() processes the gzip stream, head->done is zero until the header + is completed, at which time head->done is set to one. If a zlib stream is + being decoded, then head->done is set to -1 to indicate that there will be + no gzip header information forthcoming. Note that Z_BLOCK or Z_TREES can be + used to force inflate() to return immediately after header processing is + complete and before any actual data is decompressed. + + The text, time, xflags, and os fields are filled in with the gzip header + contents. hcrc is set to true if there is a header CRC. (The header CRC + was valid if done is set to one.) If extra is not Z_NULL, then extra_max + contains the maximum number of bytes to write to extra. Once done is true, + extra_len contains the actual extra field length, and extra contains the + extra field, or that field truncated if extra_max is less than extra_len. + If name is not Z_NULL, then up to name_max characters are written there, + terminated with a zero unless the length is greater than name_max. If + comment is not Z_NULL, then up to comm_max characters are written there, + terminated with a zero unless the length is greater than comm_max. When any + of extra, name, or comment are not Z_NULL and the respective field is not + present in the header, then that field is set to Z_NULL to signal its + absence. This allows the use of deflateSetHeader() with the returned + structure to duplicate the header. However if those fields are set to + allocated memory, then the application will need to save those pointers + elsewhere so that they can be eventually freed. + + If inflateGetHeader is not used, then the header information is simply + discarded. The header is always checked for validity, including the header + CRC if present. inflateReset() will reset the process to discard the header + information. The application would need to call inflateGetHeader() again to + retrieve the header from the next gzip stream. + + inflateGetHeader returns Z_OK if success, or Z_STREAM_ERROR if the source + stream state was inconsistent. +*/ + +/* +ZEXTERN int ZEXPORT inflateBackInit OF((z_streamp strm, int windowBits, + unsigned char FAR *window)); + + Initialize the internal stream state for decompression using inflateBack() + calls. The fields zalloc, zfree and opaque in strm must be initialized + before the call. If zalloc and zfree are Z_NULL, then the default library- + derived memory allocation routines are used. windowBits is the base two + logarithm of the window size, in the range 8..15. window is a caller + supplied buffer of that size. Except for special applications where it is + assured that deflate was used with small window sizes, windowBits must be 15 + and a 32K byte window must be supplied to be able to decompress general + deflate streams. + + See inflateBack() for the usage of these routines. + + inflateBackInit will return Z_OK on success, Z_STREAM_ERROR if any of + the parameters are invalid, Z_MEM_ERROR if the internal state could not be + allocated, or Z_VERSION_ERROR if the version of the library does not match + the version of the header file. +*/ + +typedef unsigned (*in_func) OF((void FAR *, + z_const unsigned char FAR * FAR *)); +typedef int (*out_func) OF((void FAR *, unsigned char FAR *, unsigned)); + +ZEXTERN int ZEXPORT inflateBack OF((z_streamp strm, + in_func in, void FAR *in_desc, + out_func out, void FAR *out_desc)); +/* + inflateBack() does a raw inflate with a single call using a call-back + interface for input and output. This is potentially more efficient than + inflate() for file i/o applications, in that it avoids copying between the + output and the sliding window by simply making the window itself the output + buffer. inflate() can be faster on modern CPUs when used with large + buffers. inflateBack() trusts the application to not change the output + buffer passed by the output function, at least until inflateBack() returns. + + inflateBackInit() must be called first to allocate the internal state + and to initialize the state with the user-provided window buffer. + inflateBack() may then be used multiple times to inflate a complete, raw + deflate stream with each call. inflateBackEnd() is then called to free the + allocated state. + + A raw deflate stream is one with no zlib or gzip header or trailer. + This routine would normally be used in a utility that reads zip or gzip + files and writes out uncompressed files. The utility would decode the + header and process the trailer on its own, hence this routine expects only + the raw deflate stream to decompress. This is different from the default + behavior of inflate(), which expects a zlib header and trailer around the + deflate stream. + + inflateBack() uses two subroutines supplied by the caller that are then + called by inflateBack() for input and output. inflateBack() calls those + routines until it reads a complete deflate stream and writes out all of the + uncompressed data, or until it encounters an error. The function's + parameters and return types are defined above in the in_func and out_func + typedefs. inflateBack() will call in(in_desc, &buf) which should return the + number of bytes of provided input, and a pointer to that input in buf. If + there is no input available, in() must return zero -- buf is ignored in that + case -- and inflateBack() will return a buffer error. inflateBack() will + call out(out_desc, buf, len) to write the uncompressed data buf[0..len-1]. + out() should return zero on success, or non-zero on failure. If out() + returns non-zero, inflateBack() will return with an error. Neither in() nor + out() are permitted to change the contents of the window provided to + inflateBackInit(), which is also the buffer that out() uses to write from. + The length written by out() will be at most the window size. Any non-zero + amount of input may be provided by in(). + + For convenience, inflateBack() can be provided input on the first call by + setting strm->next_in and strm->avail_in. If that input is exhausted, then + in() will be called. Therefore strm->next_in must be initialized before + calling inflateBack(). If strm->next_in is Z_NULL, then in() will be called + immediately for input. If strm->next_in is not Z_NULL, then strm->avail_in + must also be initialized, and then if strm->avail_in is not zero, input will + initially be taken from strm->next_in[0 .. strm->avail_in - 1]. + + The in_desc and out_desc parameters of inflateBack() is passed as the + first parameter of in() and out() respectively when they are called. These + descriptors can be optionally used to pass any information that the caller- + supplied in() and out() functions need to do their job. + + On return, inflateBack() will set strm->next_in and strm->avail_in to + pass back any unused input that was provided by the last in() call. The + return values of inflateBack() can be Z_STREAM_END on success, Z_BUF_ERROR + if in() or out() returned an error, Z_DATA_ERROR if there was a format error + in the deflate stream (in which case strm->msg is set to indicate the nature + of the error), or Z_STREAM_ERROR if the stream was not properly initialized. + In the case of Z_BUF_ERROR, an input or output error can be distinguished + using strm->next_in which will be Z_NULL only if in() returned an error. If + strm->next_in is not Z_NULL, then the Z_BUF_ERROR was due to out() returning + non-zero. (in() will always be called before out(), so strm->next_in is + assured to be defined if out() returns non-zero.) Note that inflateBack() + cannot return Z_OK. +*/ + +ZEXTERN int ZEXPORT inflateBackEnd OF((z_streamp strm)); +/* + All memory allocated by inflateBackInit() is freed. + + inflateBackEnd() returns Z_OK on success, or Z_STREAM_ERROR if the stream + state was inconsistent. +*/ + +ZEXTERN uLong ZEXPORT zlibCompileFlags OF((void)); +/* Return flags indicating compile-time options. + + Type sizes, two bits each, 00 = 16 bits, 01 = 32, 10 = 64, 11 = other: + 1.0: size of uInt + 3.2: size of uLong + 5.4: size of voidpf (pointer) + 7.6: size of z_off_t + + Compiler, assembler, and debug options: + 8: ZLIB_DEBUG + 9: ASMV or ASMINF -- use ASM code + 10: ZLIB_WINAPI -- exported functions use the WINAPI calling convention + 11: 0 (reserved) + + One-time table building (smaller code, but not thread-safe if true): + 12: BUILDFIXED -- build static block decoding tables when needed + 13: DYNAMIC_CRC_TABLE -- build CRC calculation tables when needed + 14,15: 0 (reserved) + + Library content (indicates missing functionality): + 16: NO_GZCOMPRESS -- gz* functions cannot compress (to avoid linking + deflate code when not needed) + 17: NO_GZIP -- deflate can't write gzip streams, and inflate can't detect + and decode gzip streams (to avoid linking crc code) + 18-19: 0 (reserved) + + Operation variations (changes in library functionality): + 20: PKZIP_BUG_WORKAROUND -- slightly more permissive inflate + 21: FASTEST -- deflate algorithm with only one, lowest compression level + 22,23: 0 (reserved) + + The sprintf variant used by gzprintf (zero is best): + 24: 0 = vs*, 1 = s* -- 1 means limited to 20 arguments after the format + 25: 0 = *nprintf, 1 = *printf -- 1 means gzprintf() not secure! + 26: 0 = returns value, 1 = void -- 1 means inferred string length returned + + Remainder: + 27-31: 0 (reserved) + */ + +#ifndef Z_SOLO + + /* utility functions */ + +/* + The following utility functions are implemented on top of the basic + stream-oriented functions. To simplify the interface, some default options + are assumed (compression level and memory usage, standard memory allocation + functions). The source code of these utility functions can be modified if + you need special options. +*/ + +ZEXTERN int ZEXPORT compress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Compresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed data. compress() is equivalent to compress2() with a level + parameter of Z_DEFAULT_COMPRESSION. + + compress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer. +*/ + +ZEXTERN int ZEXPORT compress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen, + int level)); +/* + Compresses the source buffer into the destination buffer. The level + parameter has the same meaning as in deflateInit. sourceLen is the byte + length of the source buffer. Upon entry, destLen is the total size of the + destination buffer, which must be at least the value returned by + compressBound(sourceLen). Upon exit, destLen is the actual size of the + compressed data. + + compress2 returns Z_OK if success, Z_MEM_ERROR if there was not enough + memory, Z_BUF_ERROR if there was not enough room in the output buffer, + Z_STREAM_ERROR if the level parameter is invalid. +*/ + +ZEXTERN uLong ZEXPORT compressBound OF((uLong sourceLen)); +/* + compressBound() returns an upper bound on the compressed size after + compress() or compress2() on sourceLen bytes. It would be used before a + compress() or compress2() call to allocate the destination buffer. +*/ + +ZEXTERN int ZEXPORT uncompress OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong sourceLen)); +/* + Decompresses the source buffer into the destination buffer. sourceLen is + the byte length of the source buffer. Upon entry, destLen is the total size + of the destination buffer, which must be large enough to hold the entire + uncompressed data. (The size of the uncompressed data must have been saved + previously by the compressor and transmitted to the decompressor by some + mechanism outside the scope of this compression library.) Upon exit, destLen + is the actual size of the uncompressed data. + + uncompress returns Z_OK if success, Z_MEM_ERROR if there was not + enough memory, Z_BUF_ERROR if there was not enough room in the output + buffer, or Z_DATA_ERROR if the input data was corrupted or incomplete. In + the case where there is not enough room, uncompress() will fill the output + buffer with the uncompressed data up to that point. +*/ + +ZEXTERN int ZEXPORT uncompress2 OF((Bytef *dest, uLongf *destLen, + const Bytef *source, uLong *sourceLen)); +/* + Same as uncompress, except that sourceLen is a pointer, where the + length of the source is *sourceLen. On return, *sourceLen is the number of + source bytes consumed. +*/ + + /* gzip file access functions */ + +/* + This library supports reading and writing files in gzip (.gz) format with + an interface similar to that of stdio, using the functions that start with + "gz". The gzip format is different from the zlib format. gzip is a gzip + wrapper, documented in RFC 1952, wrapped around a deflate stream. +*/ + +typedef struct gzFile_s *gzFile; /* semi-opaque gzip file descriptor */ + +/* +ZEXTERN gzFile ZEXPORT gzopen OF((const char *path, const char *mode)); + + Opens a gzip (.gz) file for reading or writing. The mode parameter is as + in fopen ("rb" or "wb") but can also include a compression level ("wb9") or + a strategy: 'f' for filtered data as in "wb6f", 'h' for Huffman-only + compression as in "wb1h", 'R' for run-length encoding as in "wb1R", or 'F' + for fixed code compression as in "wb9F". (See the description of + deflateInit2 for more information about the strategy parameter.) 'T' will + request transparent writing or appending with no compression and not using + the gzip format. + + "a" can be used instead of "w" to request that the gzip stream that will + be written be appended to the file. "+" will result in an error, since + reading and writing to the same gzip file is not supported. The addition of + "x" when writing will create the file exclusively, which fails if the file + already exists. On systems that support it, the addition of "e" when + reading or writing will set the flag to close the file on an execve() call. + + These functions, as well as gzip, will read and decode a sequence of gzip + streams in a file. The append function of gzopen() can be used to create + such a file. (Also see gzflush() for another way to do this.) When + appending, gzopen does not test whether the file begins with a gzip stream, + nor does it look for the end of the gzip streams to begin appending. gzopen + will simply append a gzip stream to the existing file. + + gzopen can be used to read a file which is not in gzip format; in this + case gzread will directly read from the file without decompression. When + reading, this will be detected automatically by looking for the magic two- + byte gzip header. + + gzopen returns NULL if the file could not be opened, if there was + insufficient memory to allocate the gzFile state, or if an invalid mode was + specified (an 'r', 'w', or 'a' was not provided, or '+' was provided). + errno can be checked to determine if the reason gzopen failed was that the + file could not be opened. +*/ + +ZEXTERN gzFile ZEXPORT gzdopen OF((int fd, const char *mode)); +/* + gzdopen associates a gzFile with the file descriptor fd. File descriptors + are obtained from calls like open, dup, creat, pipe or fileno (if the file + has been previously opened with fopen). The mode parameter is as in gzopen. + + The next call of gzclose on the returned gzFile will also close the file + descriptor fd, just like fclose(fdopen(fd, mode)) closes the file descriptor + fd. If you want to keep fd open, use fd = dup(fd_keep); gz = gzdopen(fd, + mode);. The duplicated descriptor should be saved to avoid a leak, since + gzdopen does not close fd if it fails. If you are using fileno() to get the + file descriptor from a FILE *, then you will have to use dup() to avoid + double-close()ing the file descriptor. Both gzclose() and fclose() will + close the associated file descriptor, so they need to have different file + descriptors. + + gzdopen returns NULL if there was insufficient memory to allocate the + gzFile state, if an invalid mode was specified (an 'r', 'w', or 'a' was not + provided, or '+' was provided), or if fd is -1. The file descriptor is not + used until the next gz* read, write, seek, or close operation, so gzdopen + will not detect if fd is invalid (unless fd is -1). +*/ + +ZEXTERN int ZEXPORT gzbuffer OF((gzFile file, unsigned size)); +/* + Set the internal buffer size used by this library's functions. The + default buffer size is 8192 bytes. This function must be called after + gzopen() or gzdopen(), and before any other calls that read or write the + file. The buffer memory allocation is always deferred to the first read or + write. Three times that size in buffer space is allocated. A larger buffer + size of, for example, 64K or 128K bytes will noticeably increase the speed + of decompression (reading). + + The new buffer size also affects the maximum length for gzprintf(). + + gzbuffer() returns 0 on success, or -1 on failure, such as being called + too late. +*/ + +ZEXTERN int ZEXPORT gzsetparams OF((gzFile file, int level, int strategy)); +/* + Dynamically update the compression level or strategy. See the description + of deflateInit2 for the meaning of these parameters. Previously provided + data is flushed before the parameter change. + + gzsetparams returns Z_OK if success, Z_STREAM_ERROR if the file was not + opened for writing, Z_ERRNO if there is an error writing the flushed data, + or Z_MEM_ERROR if there is a memory allocation error. +*/ + +ZEXTERN int ZEXPORT gzread OF((gzFile file, voidp buf, unsigned len)); +/* + Reads the given number of uncompressed bytes from the compressed file. If + the input file is not in gzip format, gzread copies the given number of + bytes into the buffer directly from the file. + + After reaching the end of a gzip stream in the input, gzread will continue + to read, looking for another gzip stream. Any number of gzip streams may be + concatenated in the input file, and will all be decompressed by gzread(). + If something other than a gzip stream is encountered after a gzip stream, + that remaining trailing garbage is ignored (and no error is returned). + + gzread can be used to read a gzip file that is being concurrently written. + Upon reaching the end of the input, gzread will return with the available + data. If the error code returned by gzerror is Z_OK or Z_BUF_ERROR, then + gzclearerr can be used to clear the end of file indicator in order to permit + gzread to be tried again. Z_OK indicates that a gzip stream was completed + on the last gzread. Z_BUF_ERROR indicates that the input file ended in the + middle of a gzip stream. Note that gzread does not return -1 in the event + of an incomplete gzip stream. This error is deferred until gzclose(), which + will return Z_BUF_ERROR if the last gzread ended in the middle of a gzip + stream. Alternatively, gzerror can be used before gzclose to detect this + case. + + gzread returns the number of uncompressed bytes actually read, less than + len for end of file, or -1 for error. If len is too large to fit in an int, + then nothing is read, -1 is returned, and the error state is set to + Z_STREAM_ERROR. +*/ + +ZEXTERN z_size_t ZEXPORT gzfread OF((voidp buf, z_size_t size, z_size_t nitems, + gzFile file)); +/* + Read up to nitems items of size size from file to buf, otherwise operating + as gzread() does. This duplicates the interface of stdio's fread(), with + size_t request and return types. If the library defines size_t, then + z_size_t is identical to size_t. If not, then z_size_t is an unsigned + integer type that can contain a pointer. + + gzfread() returns the number of full items read of size size, or zero if + the end of the file was reached and a full item could not be read, or if + there was an error. gzerror() must be consulted if zero is returned in + order to determine if there was an error. If the multiplication of size and + nitems overflows, i.e. the product does not fit in a z_size_t, then nothing + is read, zero is returned, and the error state is set to Z_STREAM_ERROR. + + In the event that the end of file is reached and only a partial item is + available at the end, i.e. the remaining uncompressed data length is not a + multiple of size, then the final partial item is nevetheless read into buf + and the end-of-file flag is set. The length of the partial item read is not + provided, but could be inferred from the result of gztell(). This behavior + is the same as the behavior of fread() implementations in common libraries, + but it prevents the direct use of gzfread() to read a concurrently written + file, reseting and retrying on end-of-file, when size is not 1. +*/ + +ZEXTERN int ZEXPORT gzwrite OF((gzFile file, + voidpc buf, unsigned len)); +/* + Writes the given number of uncompressed bytes into the compressed file. + gzwrite returns the number of uncompressed bytes written or 0 in case of + error. +*/ + +ZEXTERN z_size_t ZEXPORT gzfwrite OF((voidpc buf, z_size_t size, + z_size_t nitems, gzFile file)); +/* + gzfwrite() writes nitems items of size size from buf to file, duplicating + the interface of stdio's fwrite(), with size_t request and return types. If + the library defines size_t, then z_size_t is identical to size_t. If not, + then z_size_t is an unsigned integer type that can contain a pointer. + + gzfwrite() returns the number of full items written of size size, or zero + if there was an error. If the multiplication of size and nitems overflows, + i.e. the product does not fit in a z_size_t, then nothing is written, zero + is returned, and the error state is set to Z_STREAM_ERROR. +*/ + +ZEXTERN int ZEXPORTVA gzprintf Z_ARG((gzFile file, const char *format, ...)); +/* + Converts, formats, and writes the arguments to the compressed file under + control of the format string, as in fprintf. gzprintf returns the number of + uncompressed bytes actually written, or a negative zlib error code in case + of error. The number of uncompressed bytes written is limited to 8191, or + one less than the buffer size given to gzbuffer(). The caller should assure + that this limit is not exceeded. If it is exceeded, then gzprintf() will + return an error (0) with nothing written. In this case, there may also be a + buffer overflow with unpredictable consequences, which is possible only if + zlib was compiled with the insecure functions sprintf() or vsprintf() + because the secure snprintf() or vsnprintf() functions were not available. + This can be determined using zlibCompileFlags(). +*/ + +ZEXTERN int ZEXPORT gzputs OF((gzFile file, const char *s)); +/* + Writes the given null-terminated string to the compressed file, excluding + the terminating null character. + + gzputs returns the number of characters written, or -1 in case of error. +*/ + +ZEXTERN char * ZEXPORT gzgets OF((gzFile file, char *buf, int len)); +/* + Reads bytes from the compressed file until len-1 characters are read, or a + newline character is read and transferred to buf, or an end-of-file + condition is encountered. If any characters are read or if len == 1, the + string is terminated with a null character. If no characters are read due + to an end-of-file or len < 1, then the buffer is left untouched. + + gzgets returns buf which is a null-terminated string, or it returns NULL + for end-of-file or in case of error. If there was an error, the contents at + buf are indeterminate. +*/ + +ZEXTERN int ZEXPORT gzputc OF((gzFile file, int c)); +/* + Writes c, converted to an unsigned char, into the compressed file. gzputc + returns the value that was written, or -1 in case of error. +*/ + +ZEXTERN int ZEXPORT gzgetc OF((gzFile file)); +/* + Reads one byte from the compressed file. gzgetc returns this byte or -1 + in case of end of file or error. This is implemented as a macro for speed. + As such, it does not do all of the checking the other functions do. I.e. + it does not check to see if file is NULL, nor whether the structure file + points to has been clobbered or not. +*/ + +ZEXTERN int ZEXPORT gzungetc OF((int c, gzFile file)); +/* + Push one character back onto the stream to be read as the first character + on the next read. At least one character of push-back is allowed. + gzungetc() returns the character pushed, or -1 on failure. gzungetc() will + fail if c is -1, and may fail if a character has been pushed but not read + yet. If gzungetc is used immediately after gzopen or gzdopen, at least the + output buffer size of pushed characters is allowed. (See gzbuffer above.) + The pushed character will be discarded if the stream is repositioned with + gzseek() or gzrewind(). +*/ + +ZEXTERN int ZEXPORT gzflush OF((gzFile file, int flush)); +/* + Flushes all pending output into the compressed file. The parameter flush + is as in the deflate() function. The return value is the zlib error number + (see function gzerror below). gzflush is only permitted when writing. + + If the flush parameter is Z_FINISH, the remaining data is written and the + gzip stream is completed in the output. If gzwrite() is called again, a new + gzip stream will be started in the output. gzread() is able to read such + concatenated gzip streams. + + gzflush should be called only when strictly necessary because it will + degrade compression if called too often. +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile file, + z_off_t offset, int whence)); + + Sets the starting position for the next gzread or gzwrite on the given + compressed file. The offset represents a number of bytes in the + uncompressed data stream. The whence parameter is defined as in lseek(2); + the value SEEK_END is not supported. + + If the file is opened for reading, this function is emulated but can be + extremely slow. If the file is opened for writing, only forward seeks are + supported; gzseek then compresses a sequence of zeroes up to the new + starting position. + + gzseek returns the resulting offset location as measured in bytes from + the beginning of the uncompressed stream, or -1 in case of error, in + particular if the file is opened for writing and the new starting position + would be before the current position. +*/ + +ZEXTERN int ZEXPORT gzrewind OF((gzFile file)); +/* + Rewinds the given file. This function is supported only for reading. + + gzrewind(file) is equivalent to (int)gzseek(file, 0L, SEEK_SET) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gztell OF((gzFile file)); + + Returns the starting position for the next gzread or gzwrite on the given + compressed file. This position represents a number of bytes in the + uncompressed data stream, and is zero when starting, even if appending or + reading a gzip stream from the middle of a file using gzdopen(). + + gztell(file) is equivalent to gzseek(file, 0L, SEEK_CUR) +*/ + +/* +ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile file)); + + Returns the current offset in the file being read or written. This offset + includes the count of bytes that precede the gzip stream, for example when + appending or when using gzdopen() for reading. When reading, the offset + does not include as yet unused buffered input. This information can be used + for a progress indicator. On error, gzoffset() returns -1. +*/ + +ZEXTERN int ZEXPORT gzeof OF((gzFile file)); +/* + Returns true (1) if the end-of-file indicator has been set while reading, + false (0) otherwise. Note that the end-of-file indicator is set only if the + read tried to go past the end of the input, but came up short. Therefore, + just like feof(), gzeof() may return false even if there is no more data to + read, in the event that the last read request was for the exact number of + bytes remaining in the input file. This will happen if the input file size + is an exact multiple of the buffer size. + + If gzeof() returns true, then the read functions will return no more data, + unless the end-of-file indicator is reset by gzclearerr() and the input file + has grown since the previous end of file was detected. +*/ + +ZEXTERN int ZEXPORT gzdirect OF((gzFile file)); +/* + Returns true (1) if file is being copied directly while reading, or false + (0) if file is a gzip stream being decompressed. + + If the input file is empty, gzdirect() will return true, since the input + does not contain a gzip stream. + + If gzdirect() is used immediately after gzopen() or gzdopen() it will + cause buffers to be allocated to allow reading the file to determine if it + is a gzip file. Therefore if gzbuffer() is used, it should be called before + gzdirect(). + + When writing, gzdirect() returns true (1) if transparent writing was + requested ("wT" for the gzopen() mode), or false (0) otherwise. (Note: + gzdirect() is not needed when writing. Transparent writing must be + explicitly requested, so the application already knows the answer. When + linking statically, using gzdirect() will include all of the zlib code for + gzip file reading and decompression, which may not be desired.) +*/ + +ZEXTERN int ZEXPORT gzclose OF((gzFile file)); +/* + Flushes all pending output if necessary, closes the compressed file and + deallocates the (de)compression state. Note that once file is closed, you + cannot call gzerror with file, since its structures have been deallocated. + gzclose must not be called more than once on the same file, just as free + must not be called more than once on the same allocation. + + gzclose will return Z_STREAM_ERROR if file is not valid, Z_ERRNO on a + file operation error, Z_MEM_ERROR if out of memory, Z_BUF_ERROR if the + last read ended in the middle of a gzip stream, or Z_OK on success. +*/ + +ZEXTERN int ZEXPORT gzclose_r OF((gzFile file)); +ZEXTERN int ZEXPORT gzclose_w OF((gzFile file)); +/* + Same as gzclose(), but gzclose_r() is only for use when reading, and + gzclose_w() is only for use when writing or appending. The advantage to + using these instead of gzclose() is that they avoid linking in zlib + compression or decompression code that is not used when only reading or only + writing respectively. If gzclose() is used, then both compression and + decompression code will be included the application when linking to a static + zlib library. +*/ + +ZEXTERN const char * ZEXPORT gzerror OF((gzFile file, int *errnum)); +/* + Returns the error message for the last error which occurred on the given + compressed file. errnum is set to zlib error number. If an error occurred + in the file system and not in the compression library, errnum is set to + Z_ERRNO and the application may consult errno to get the exact error code. + + The application must not modify the returned string. Future calls to + this function may invalidate the previously returned string. If file is + closed, then the string previously returned by gzerror will no longer be + available. + + gzerror() should be used to distinguish errors from end-of-file for those + functions above that do not distinguish those cases in their return values. +*/ + +ZEXTERN void ZEXPORT gzclearerr OF((gzFile file)); +/* + Clears the error and end-of-file flags for file. This is analogous to the + clearerr() function in stdio. This is useful for continuing to read a gzip + file that is being written concurrently. +*/ + +#endif /* !Z_SOLO */ + + /* checksum functions */ + +/* + These functions are not related to compression but are exported + anyway because they might be useful in applications using the compression + library. +*/ + +ZEXTERN uLong ZEXPORT adler32 OF((uLong adler, const Bytef *buf, uInt len)); +/* + Update a running Adler-32 checksum with the bytes buf[0..len-1] and + return the updated checksum. If buf is Z_NULL, this function returns the + required initial value for the checksum. + + An Adler-32 checksum is almost as reliable as a CRC-32 but can be computed + much faster. + + Usage example: + + uLong adler = adler32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + adler = adler32(adler, buffer, length); + } + if (adler != original_adler) error(); +*/ + +ZEXTERN uLong ZEXPORT adler32_z OF((uLong adler, const Bytef *buf, + z_size_t len)); +/* + Same as adler32(), but with a size_t length. +*/ + +/* +ZEXTERN uLong ZEXPORT adler32_combine OF((uLong adler1, uLong adler2, + z_off_t len2)); + + Combine two Adler-32 checksums into one. For two sequences of bytes, seq1 + and seq2 with lengths len1 and len2, Adler-32 checksums were calculated for + each, adler1 and adler2. adler32_combine() returns the Adler-32 checksum of + seq1 and seq2 concatenated, requiring only adler1, adler2, and len2. Note + that the z_off_t type (like off_t) is a signed integer. If len2 is + negative, the result has no meaning or utility. +*/ + +ZEXTERN uLong ZEXPORT crc32 OF((uLong crc, const Bytef *buf, uInt len)); +/* + Update a running CRC-32 with the bytes buf[0..len-1] and return the + updated CRC-32. If buf is Z_NULL, this function returns the required + initial value for the crc. Pre- and post-conditioning (one's complement) is + performed within this function so it shouldn't be done by the application. + + Usage example: + + uLong crc = crc32(0L, Z_NULL, 0); + + while (read_buffer(buffer, length) != EOF) { + crc = crc32(crc, buffer, length); + } + if (crc != original_crc) error(); +*/ + +ZEXTERN uLong ZEXPORT crc32_z OF((uLong adler, const Bytef *buf, + z_size_t len)); +/* + Same as crc32(), but with a size_t length. +*/ + +/* +ZEXTERN uLong ZEXPORT crc32_combine OF((uLong crc1, uLong crc2, z_off_t len2)); + + Combine two CRC-32 check values into one. For two sequences of bytes, + seq1 and seq2 with lengths len1 and len2, CRC-32 check values were + calculated for each, crc1 and crc2. crc32_combine() returns the CRC-32 + check value of seq1 and seq2 concatenated, requiring only crc1, crc2, and + len2. +*/ + + + /* various hacks, don't look :) */ + +/* deflateInit and inflateInit are macros to allow checking the zlib version + * and the compiler's view of z_stream: + */ +ZEXTERN int ZEXPORT deflateInit_ OF((z_streamp strm, int level, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateInit_ OF((z_streamp strm, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT deflateInit2_ OF((z_streamp strm, int level, int method, + int windowBits, int memLevel, + int strategy, const char *version, + int stream_size)); +ZEXTERN int ZEXPORT inflateInit2_ OF((z_streamp strm, int windowBits, + const char *version, int stream_size)); +ZEXTERN int ZEXPORT inflateBackInit_ OF((z_streamp strm, int windowBits, + unsigned char FAR *window, + const char *version, + int stream_size)); +#ifdef Z_PREFIX_SET +# define z_deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) +# define z_inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) +# define z_deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) +# define z_inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ + (int)sizeof(z_stream)) +# define z_inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, (int)sizeof(z_stream)) +#else +# define deflateInit(strm, level) \ + deflateInit_((strm), (level), ZLIB_VERSION, (int)sizeof(z_stream)) +# define inflateInit(strm) \ + inflateInit_((strm), ZLIB_VERSION, (int)sizeof(z_stream)) +# define deflateInit2(strm, level, method, windowBits, memLevel, strategy) \ + deflateInit2_((strm),(level),(method),(windowBits),(memLevel),\ + (strategy), ZLIB_VERSION, (int)sizeof(z_stream)) +# define inflateInit2(strm, windowBits) \ + inflateInit2_((strm), (windowBits), ZLIB_VERSION, \ + (int)sizeof(z_stream)) +# define inflateBackInit(strm, windowBits, window) \ + inflateBackInit_((strm), (windowBits), (window), \ + ZLIB_VERSION, (int)sizeof(z_stream)) +#endif + +#ifndef Z_SOLO + +/* gzgetc() macro and its supporting function and exposed data structure. Note + * that the real internal state is much larger than the exposed structure. + * This abbreviated structure exposes just enough for the gzgetc() macro. The + * user should not mess with these exposed elements, since their names or + * behavior could change in the future, perhaps even capriciously. They can + * only be used by the gzgetc() macro. You have been warned. + */ +struct gzFile_s { + unsigned have; + unsigned char *next; + z_off64_t pos; +}; +ZEXTERN int ZEXPORT gzgetc_ OF((gzFile file)); /* backward compatibility */ +#ifdef Z_PREFIX_SET +# undef z_gzgetc +# define z_gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) +#else +# define gzgetc(g) \ + ((g)->have ? ((g)->have--, (g)->pos++, *((g)->next)++) : (gzgetc)(g)) +#endif + +/* provide 64-bit offset functions if _LARGEFILE64_SOURCE defined, and/or + * change the regular functions to 64 bits if _FILE_OFFSET_BITS is 64 (if + * both are true, the application gets the *64 functions, and the regular + * functions are changed to 64 bits) -- in case these are set on systems + * without large file support, _LFS64_LARGEFILE must also be true + */ +#ifdef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int)); + ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off64_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off64_t)); +#endif + +#if !defined(ZLIB_INTERNAL) && defined(Z_WANT64) +# ifdef Z_PREFIX_SET +# define z_gzopen z_gzopen64 +# define z_gzseek z_gzseek64 +# define z_gztell z_gztell64 +# define z_gzoffset z_gzoffset64 +# define z_adler32_combine z_adler32_combine64 +# define z_crc32_combine z_crc32_combine64 +# else +# define gzopen gzopen64 +# define gzseek gzseek64 +# define gztell gztell64 +# define gzoffset gzoffset64 +# define adler32_combine adler32_combine64 +# define crc32_combine crc32_combine64 +# endif +# ifndef Z_LARGE64 + ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek64 OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell64 OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset64 OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t)); +# endif +#else + ZEXTERN gzFile ZEXPORT gzopen OF((const char *, const char *)); + ZEXTERN z_off_t ZEXPORT gzseek OF((gzFile, z_off_t, int)); + ZEXTERN z_off_t ZEXPORT gztell OF((gzFile)); + ZEXTERN z_off_t ZEXPORT gzoffset OF((gzFile)); + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); +#endif + +#else /* Z_SOLO */ + + ZEXTERN uLong ZEXPORT adler32_combine OF((uLong, uLong, z_off_t)); + ZEXTERN uLong ZEXPORT crc32_combine OF((uLong, uLong, z_off_t)); + +#endif /* !Z_SOLO */ + +/* undocumented functions */ +ZEXTERN const char * ZEXPORT zError OF((int)); +ZEXTERN int ZEXPORT inflateSyncPoint OF((z_streamp)); +ZEXTERN const z_crc_t FAR * ZEXPORT get_crc_table OF((void)); +ZEXTERN int ZEXPORT inflateUndermine OF((z_streamp, int)); +ZEXTERN int ZEXPORT inflateValidate OF((z_streamp, int)); +ZEXTERN unsigned long ZEXPORT inflateCodesUsed OF ((z_streamp)); +ZEXTERN int ZEXPORT inflateResetKeep OF((z_streamp)); +ZEXTERN int ZEXPORT deflateResetKeep OF((z_streamp)); +#if (defined(_WIN32) || defined(__CYGWIN__)) && !defined(Z_SOLO) +ZEXTERN gzFile ZEXPORT gzopen_w OF((const wchar_t *path, + const char *mode)); +#endif +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +ZEXTERN int ZEXPORTVA gzvprintf Z_ARG((gzFile file, + const char *format, + va_list va)); +# endif +#endif + +#ifdef __cplusplus +} +#endif + +#endif /* ZLIB_H */ diff --git a/NorthstarDedicatedTest/include/zlib.lib b/NorthstarDedicatedTest/include/zlib.lib new file mode 100644 index 0000000000000000000000000000000000000000..dca6053a88996d2f365117192ab4ce044e774419 GIT binary patch literal 402696 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%0D+62uPB>%}K=?rnR*X(;FaxFCCb-wY_wp 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 D7b)*L literal 0 HcmV?d00001 diff --git a/NorthstarDedicatedTest/include/zlib/gzip/compress.hpp b/NorthstarDedicatedTest/include/zlib/gzip/compress.hpp new file mode 100644 index 00000000..c7da9447 --- /dev/null +++ b/NorthstarDedicatedTest/include/zlib/gzip/compress.hpp @@ -0,0 +1,113 @@ +#include + +// zlib +#include + +// std +#include +#include +#include + +namespace gzip { + +class Compressor +{ + std::size_t max_; + int level_; + + public: + Compressor(int level = Z_DEFAULT_COMPRESSION, + std::size_t max_bytes = 2000000000) // by default refuse operation if uncompressed data is > 2GB + : max_(max_bytes), + level_(level) + { + } + + template + void compress(InputType& output, + const char* data, + std::size_t size) const + { + +#ifdef DEBUG + // Verify if size input will fit into unsigned int, type used for zlib's avail_in + if (size > std::numeric_limits::max()) + { + throw std::runtime_error("size arg is too large to fit into unsigned int type"); + } +#endif + if (size > max_) + { + throw std::runtime_error("size may use more memory than intended when decompressing"); + } + + z_stream deflate_s; + deflate_s.zalloc = Z_NULL; + deflate_s.zfree = Z_NULL; + deflate_s.opaque = Z_NULL; + deflate_s.avail_in = 0; + deflate_s.next_in = Z_NULL; + + // 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. + // This range of values also changes the decoding type: + // -8 to -15 for raw deflate + // 8 to 15 for zlib + // (8 to 15) + 16 for gzip + // (8 to 15) + 32 to automatically detect gzip/zlib header (decompression/inflate only) + constexpr int window_bits = 15 + 16; // gzip with windowbits of 15 + + constexpr int mem_level = 8; + // The memory requirements for deflate are (in bytes): + // (1 << (window_bits+2)) + (1 << (mem_level+9)) + // with a default value of 8 for mem_level and our window_bits of 15 + // this is 128Kb + +#pragma GCC diagnostic push +#pragma GCC diagnostic ignored "-Wold-style-cast" + if (deflateInit2(&deflate_s, level_, Z_DEFLATED, window_bits, mem_level, Z_DEFAULT_STRATEGY) != Z_OK) + { + throw std::runtime_error("deflate init failed"); + } +#pragma GCC diagnostic pop + + deflate_s.next_in = reinterpret_cast(data); + deflate_s.avail_in = static_cast(size); + + std::size_t size_compressed = 0; + do + { + size_t increase = size / 2 + 1024; + if (output.size() < (size_compressed + increase)) + { + output.resize(size_compressed + increase); + } + // There is no way we see that "increase" would not fit in an unsigned int, + // hence we use static cast here to avoid -Wshorten-64-to-32 error + deflate_s.avail_out = static_cast(increase); + deflate_s.next_out = reinterpret_cast((&output[0] + size_compressed)); + // From http://www.zlib.net/zlib_how.html + // "deflate() has a return value that can indicate errors, yet we do not check it here. + // Why not? Well, it turns out that deflate() can do no wrong here." + // Basically only possible error is from deflateInit not working properly + deflate(&deflate_s, Z_FINISH); + size_compressed += (increase - deflate_s.avail_out); + } while (deflate_s.avail_out == 0); + + deflateEnd(&deflate_s); + output.resize(size_compressed); + } +}; + +inline std::string compress(const char* data, + std::size_t size, + int level = Z_DEFAULT_COMPRESSION) +{ + Compressor comp(level); + std::string output; + comp.compress(output, data, size); + return output; +} + +} // namespace gzip diff --git a/NorthstarDedicatedTest/include/zlib/gzip/config.hpp b/NorthstarDedicatedTest/include/zlib/gzip/config.hpp new file mode 100644 index 00000000..21f34a0b --- /dev/null +++ b/NorthstarDedicatedTest/include/zlib/gzip/config.hpp @@ -0,0 +1,5 @@ +#pragma once + +#ifndef ZLIB_CONST +#define ZLIB_CONST +#endif \ No newline at end of file diff --git a/NorthstarDedicatedTest/include/zlib/gzip/version.hpp b/NorthstarDedicatedTest/include/zlib/gzip/version.hpp new file mode 100644 index 00000000..47af692e --- /dev/null +++ b/NorthstarDedicatedTest/include/zlib/gzip/version.hpp @@ -0,0 +1,16 @@ +#pragma once + +/// The major version number +#define GZIP_VERSION_MAJOR 1 + +/// The minor version number +#define GZIP_VERSION_MINOR 0 + +/// The patch number +#define GZIP_VERSION_PATCH 0 + +/// The complete version number +#define GZIP_VERSION_CODE (GZIP_VERSION_MAJOR * 10000 + GZIP_VERSION_MINOR * 100 + GZIP_VERSION_PATCH) + +/// Version number as string +#define GZIP_VERSION_STRING "1.0.0" \ No newline at end of file diff --git a/NorthstarDedicatedTest/include/zlib/zconf.h b/NorthstarDedicatedTest/include/zlib/zconf.h new file mode 100644 index 00000000..5e1d68a0 --- /dev/null +++ b/NorthstarDedicatedTest/include/zlib/zconf.h @@ -0,0 +1,534 @@ +/* zconf.h -- configuration of the zlib compression library + * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler + * For conditions of distribution and use, see copyright notice in zlib.h + */ + +/* @(#) $Id$ */ + +#ifndef ZCONF_H +#define ZCONF_H + +/* + * If you *really* need a unique prefix for all types and library functions, + * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it. + * Even better than compiling with -DZ_PREFIX would be to use configure to set + * this permanently in zconf.h using "./configure --zprefix". + */ +#ifdef Z_PREFIX /* may be set to #if 1 by ./configure */ +# define Z_PREFIX_SET + +/* all linked symbols and init macros */ +# define _dist_code z__dist_code +# define _length_code z__length_code +# define _tr_align z__tr_align +# define _tr_flush_bits z__tr_flush_bits +# define _tr_flush_block z__tr_flush_block +# define _tr_init z__tr_init +# define _tr_stored_block z__tr_stored_block +# define _tr_tally z__tr_tally +# define adler32 z_adler32 +# define adler32_combine z_adler32_combine +# define adler32_combine64 z_adler32_combine64 +# define adler32_z z_adler32_z +# ifndef Z_SOLO +# define compress z_compress +# define compress2 z_compress2 +# define compressBound z_compressBound +# endif +# define crc32 z_crc32 +# define crc32_combine z_crc32_combine +# define crc32_combine64 z_crc32_combine64 +# define crc32_z z_crc32_z +# define deflate z_deflate +# define deflateBound z_deflateBound +# define deflateCopy z_deflateCopy +# define deflateEnd z_deflateEnd +# define deflateGetDictionary z_deflateGetDictionary +# define deflateInit z_deflateInit +# define deflateInit2 z_deflateInit2 +# define deflateInit2_ z_deflateInit2_ +# define deflateInit_ z_deflateInit_ +# define deflateParams z_deflateParams +# define deflatePending z_deflatePending +# define deflatePrime z_deflatePrime +# define deflateReset z_deflateReset +# define deflateResetKeep z_deflateResetKeep +# define deflateSetDictionary z_deflateSetDictionary +# define deflateSetHeader z_deflateSetHeader +# define deflateTune z_deflateTune +# define deflate_copyright z_deflate_copyright +# define get_crc_table z_get_crc_table +# ifndef Z_SOLO +# define gz_error z_gz_error +# define gz_intmax z_gz_intmax +# define gz_strwinerror z_gz_strwinerror +# define gzbuffer z_gzbuffer +# define gzclearerr z_gzclearerr +# define gzclose z_gzclose +# define gzclose_r z_gzclose_r +# define gzclose_w z_gzclose_w +# define gzdirect z_gzdirect +# define gzdopen z_gzdopen +# define gzeof z_gzeof +# define gzerror z_gzerror +# define gzflush z_gzflush +# define gzfread z_gzfread +# define gzfwrite z_gzfwrite +# define gzgetc z_gzgetc +# define gzgetc_ z_gzgetc_ +# define gzgets z_gzgets +# define gzoffset z_gzoffset +# define gzoffset64 z_gzoffset64 +# define gzopen z_gzopen +# define gzopen64 z_gzopen64 +# ifdef _WIN32 +# define gzopen_w z_gzopen_w +# endif +# define gzprintf z_gzprintf +# define gzputc z_gzputc +# define gzputs z_gzputs +# define gzread z_gzread +# define gzrewind z_gzrewind +# define gzseek z_gzseek +# define gzseek64 z_gzseek64 +# define gzsetparams z_gzsetparams +# define gztell z_gztell +# define gztell64 z_gztell64 +# define gzungetc z_gzungetc +# define gzvprintf z_gzvprintf +# define gzwrite z_gzwrite +# endif +# define inflate z_inflate +# define inflateBack z_inflateBack +# define inflateBackEnd z_inflateBackEnd +# define inflateBackInit z_inflateBackInit +# define inflateBackInit_ z_inflateBackInit_ +# define inflateCodesUsed z_inflateCodesUsed +# define inflateCopy z_inflateCopy +# define inflateEnd z_inflateEnd +# define inflateGetDictionary z_inflateGetDictionary +# define inflateGetHeader z_inflateGetHeader +# define inflateInit z_inflateInit +# define inflateInit2 z_inflateInit2 +# define inflateInit2_ z_inflateInit2_ +# define inflateInit_ z_inflateInit_ +# define inflateMark z_inflateMark +# define inflatePrime z_inflatePrime +# define inflateReset z_inflateReset +# define inflateReset2 z_inflateReset2 +# define inflateResetKeep z_inflateResetKeep +# define inflateSetDictionary z_inflateSetDictionary +# define inflateSync z_inflateSync +# define inflateSyncPoint z_inflateSyncPoint +# define inflateUndermine z_inflateUndermine +# define inflateValidate z_inflateValidate +# define inflate_copyright z_inflate_copyright +# define inflate_fast z_inflate_fast +# define inflate_table z_inflate_table +# ifndef Z_SOLO +# define uncompress z_uncompress +# define uncompress2 z_uncompress2 +# endif +# define zError z_zError +# ifndef Z_SOLO +# define zcalloc z_zcalloc +# define zcfree z_zcfree +# endif +# define zlibCompileFlags z_zlibCompileFlags +# define zlibVersion z_zlibVersion + +/* all zlib typedefs in zlib.h and zconf.h */ +# define Byte z_Byte +# define Bytef z_Bytef +# define alloc_func z_alloc_func +# define charf z_charf +# define free_func z_free_func +# ifndef Z_SOLO +# define gzFile z_gzFile +# endif +# define gz_header z_gz_header +# define gz_headerp z_gz_headerp +# define in_func z_in_func +# define intf z_intf +# define out_func z_out_func +# define uInt z_uInt +# define uIntf z_uIntf +# define uLong z_uLong +# define uLongf z_uLongf +# define voidp z_voidp +# define voidpc z_voidpc +# define voidpf z_voidpf + +/* all zlib structs in zlib.h and zconf.h */ +# define gz_header_s z_gz_header_s +# define internal_state z_internal_state + +#endif + +#if defined(__MSDOS__) && !defined(MSDOS) +# define MSDOS +#endif +#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2) +# define OS2 +#endif +#if defined(_WINDOWS) && !defined(WINDOWS) +# define WINDOWS +#endif +#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__) +# ifndef WIN32 +# define WIN32 +# endif +#endif +#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32) +# if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__) +# ifndef SYS16BIT +# define SYS16BIT +# endif +# endif +#endif + +/* + * Compile with -DMAXSEG_64K if the alloc function cannot allocate more + * than 64k bytes at a time (needed on systems with 16-bit int). + */ +#ifdef SYS16BIT +# define MAXSEG_64K +#endif +#ifdef MSDOS +# define UNALIGNED_OK +#endif + +#ifdef __STDC_VERSION__ +# ifndef STDC +# define STDC +# endif +# if __STDC_VERSION__ >= 199901L +# ifndef STDC99 +# define STDC99 +# endif +# endif +#endif +#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus)) +# define STDC +#endif +#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__)) +# define STDC +#endif +#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32)) +# define STDC +#endif +#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__)) +# define STDC +#endif + +#if defined(__OS400__) && !defined(STDC) /* iSeries (formerly AS/400). */ +# define STDC +#endif + +#ifndef STDC +# ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */ +# define const /* note: need a more gentle solution here */ +# endif +#endif + +#if defined(ZLIB_CONST) && !defined(z_const) +# define z_const const +#else +# define z_const +#endif + +#ifdef Z_SOLO + typedef unsigned long z_size_t; +#else +# define z_longlong long long +# if defined(NO_SIZE_T) + typedef unsigned NO_SIZE_T z_size_t; +# elif defined(STDC) +# include + typedef size_t z_size_t; +# else + typedef unsigned long z_size_t; +# endif +# undef z_longlong +#endif + +/* Maximum value for memLevel in deflateInit2 */ +#ifndef MAX_MEM_LEVEL +# ifdef MAXSEG_64K +# define MAX_MEM_LEVEL 8 +# else +# define MAX_MEM_LEVEL 9 +# endif +#endif + +/* Maximum value for windowBits in deflateInit2 and inflateInit2. + * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files + * created by gzip. (Files created by minigzip can still be extracted by + * gzip.) + */ +#ifndef MAX_WBITS +# define MAX_WBITS 15 /* 32K LZ77 window */ +#endif + +/* The memory requirements for deflate are (in bytes): + (1 << (windowBits+2)) + (1 << (memLevel+9)) + that is: 128K for windowBits=15 + 128K for memLevel = 8 (default values) + plus a few kilobytes for small objects. For example, if you want to reduce + the default memory requirements from 256K to 128K, compile with + make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7" + Of course this will generally degrade compression (there's no free lunch). + + The memory requirements for inflate are (in bytes) 1 << windowBits + that is, 32K for windowBits=15 (default value) plus about 7 kilobytes + for small objects. +*/ + + /* Type declarations */ + +#ifndef OF /* function prototypes */ +# ifdef STDC +# define OF(args) args +# else +# define OF(args) () +# endif +#endif + +#ifndef Z_ARG /* function prototypes for stdarg */ +# if defined(STDC) || defined(Z_HAVE_STDARG_H) +# define Z_ARG(args) args +# else +# define Z_ARG(args) () +# endif +#endif + +/* The following definitions for FAR are needed only for MSDOS mixed + * model programming (small or medium model with some far allocations). + * This was tested only with MSC; for other MSDOS compilers you may have + * to define NO_MEMCPY in zutil.h. If you don't need the mixed model, + * just define FAR to be empty. + */ +#ifdef SYS16BIT +# if defined(M_I86SM) || defined(M_I86MM) + /* MSC small or medium model */ +# define SMALL_MEDIUM +# ifdef _MSC_VER +# define FAR _far +# else +# define FAR far +# endif +# endif +# if (defined(__SMALL__) || defined(__MEDIUM__)) + /* Turbo C small or medium model */ +# define SMALL_MEDIUM +# ifdef __BORLANDC__ +# define FAR _far +# else +# define FAR far +# endif +# endif +#endif + +#if defined(WINDOWS) || defined(WIN32) + /* If building or using zlib as a DLL, define ZLIB_DLL. + * This is not mandatory, but it offers a little performance increase. + */ +# ifdef ZLIB_DLL +# if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500)) +# ifdef ZLIB_INTERNAL +# define ZEXTERN extern __declspec(dllexport) +# else +# define ZEXTERN extern __declspec(dllimport) +# endif +# endif +# endif /* ZLIB_DLL */ + /* If building or using zlib with the WINAPI/WINAPIV calling convention, + * define ZLIB_WINAPI. + * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI. + */ +# ifdef ZLIB_WINAPI +# ifdef FAR +# undef FAR +# endif +# include + /* No need for _export, use ZLIB.DEF instead. */ + /* For complete Windows compatibility, use WINAPI, not __stdcall. */ +# define ZEXPORT WINAPI +# ifdef WIN32 +# define ZEXPORTVA WINAPIV +# else +# define ZEXPORTVA FAR CDECL +# endif +# endif +#endif + +#if defined (__BEOS__) +# ifdef ZLIB_DLL +# ifdef ZLIB_INTERNAL +# define ZEXPORT __declspec(dllexport) +# define ZEXPORTVA __declspec(dllexport) +# else +# define ZEXPORT __declspec(dllimport) +# define ZEXPORTVA __declspec(dllimport) +# endif +# endif +#endif + +#ifndef ZEXTERN +# define ZEXTERN extern +#endif +#ifndef ZEXPORT +# define ZEXPORT +#endif +#ifndef ZEXPORTVA +# define ZEXPORTVA +#endif + +#ifndef FAR +# define FAR +#endif + +#if !defined(__MACTYPES__) +typedef unsigned char Byte; /* 8 bits */ +#endif +typedef unsigned int uInt; /* 16 bits or more */ +typedef unsigned long uLong; /* 32 bits or more */ + +#ifdef SMALL_MEDIUM + /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */ +# define Bytef Byte FAR +#else + typedef Byte FAR Bytef; +#endif +typedef char FAR charf; +typedef int FAR intf; +typedef uInt FAR uIntf; +typedef uLong FAR uLongf; + +#ifdef STDC + typedef void const *voidpc; + typedef void FAR *voidpf; + typedef void *voidp; +#else + typedef Byte const *voidpc; + typedef Byte FAR *voidpf; + typedef Byte *voidp; +#endif + +#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC) +# include +# if (UINT_MAX == 0xffffffffUL) +# define Z_U4 unsigned +# elif (ULONG_MAX == 0xffffffffUL) +# define Z_U4 unsigned long +# elif (USHRT_MAX == 0xffffffffUL) +# define Z_U4 unsigned short +# endif +#endif + +#ifdef Z_U4 + typedef Z_U4 z_crc_t; +#else + typedef unsigned long z_crc_t; +#endif + +#ifdef HAVE_UNISTD_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_UNISTD_H +#endif + +#ifdef HAVE_STDARG_H /* may be set to #if 1 by ./configure */ +# define Z_HAVE_STDARG_H +#endif + +#ifdef STDC +# ifndef Z_SOLO +# include /* for off_t */ +# endif +#endif + +#if defined(STDC) || defined(Z_HAVE_STDARG_H) +# ifndef Z_SOLO +# include /* for va_list */ +# endif +#endif + +#ifdef _WIN32 +# ifndef Z_SOLO +# include /* for wchar_t */ +# endif +#endif + +/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and + * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even + * though the former does not conform to the LFS document), but considering + * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as + * equivalently requesting no 64-bit operations + */ +#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1 +# undef _LARGEFILE64_SOURCE +#endif + +#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H) +# define Z_HAVE_UNISTD_H +#endif +#ifndef Z_SOLO +# if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE) +# include /* for SEEK_*, off_t, and _LFS64_LARGEFILE */ +# ifdef VMS +# include /* for off_t */ +# endif +# ifndef z_off_t +# define z_off_t off_t +# endif +# endif +#endif + +#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0 +# define Z_LFS64 +#endif + +#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64) +# define Z_LARGE64 +#endif + +#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64) +# define Z_WANT64 +#endif + +#if !defined(SEEK_SET) && !defined(Z_SOLO) +# define SEEK_SET 0 /* Seek from beginning of file. */ +# define SEEK_CUR 1 /* Seek from current position. */ +# define SEEK_END 2 /* Set file pointer to EOF plus "offset" */ +#endif + +#ifndef z_off_t +# define z_off_t long +#endif + +#if !defined(_WIN32) && defined(Z_LARGE64) +# define z_off64_t off64_t +#else +# if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO) +# define z_off64_t __int64 +# else +# define z_off64_t z_off_t +# endif +#endif + +/* MVS linker does not support external names larger than 8 bytes */ +#if defined(__MVS__) + #pragma map(deflateInit_,"DEIN") + #pragma map(deflateInit2_,"DEIN2") + #pragma map(deflateEnd,"DEEND") + #pragma map(deflateBound,"DEBND") + #pragma map(inflateInit_,"ININ") + #pragma map(inflateInit2_,"ININ2") + #pragma map(inflateEnd,"INEND") + #pragma map(inflateSync,"INSY") + #pragma map(inflateSetDictionary,"INSEDI") + #pragma map(compressBound,"CMBND") + #pragma map(inflate_table,"INTABL") + #pragma map(inflate_fast,"INFA") + #pragma map(inflate_copyright,"INCOPY") +#endif + +#endif /* ZCONF_H */ diff --git a/NorthstarDedicatedTest/logCompression.cpp b/NorthstarDedicatedTest/logCompression.cpp new file mode 100644 index 00000000..d9e89fdf --- /dev/null +++ b/NorthstarDedicatedTest/logCompression.cpp @@ -0,0 +1,64 @@ +#include "pch.h" +#include "logCompression.h" +#include +#include +#include +#include +#include "configurables.h" +#include "zlib/gzip/compress.hpp" +#include "zlib/gzip/config.hpp" +#include + +#define CHUNK 16384 + +namespace fs = std::filesystem; +using namespace std; + +bool compressFile(const fs::path path) +{ + // read log file + ofstream output; + string filename(path.string()); + cout << "Compressing : '" + filename + "'" << endl; + ifstream input(filename, ios_base::binary); + if (!input.is_open()) + { + cerr << "Could not open : '" + filename + "'" << endl; + return false; + } + string log_data((istreambuf_iterator(input.rdbuf())), istreambuf_iterator()); + input.close(); + // compress log file + string compressed_data = gzip::compress(log_data.data(), log_data.size()); + // write log file gzip + output.open(filename + ".gz"); + if (!output.is_open()) + { + cerr << "Could not write : '" + filename + "'" << endl; + return false; + } + output << compressed_data; + output.close(); + // delete log file + remove(path); + if (std::ifstream(path)) + { + cerr << "Error deleting : '%s'" + filename + "'" << endl; + return false; + } + return true; +} + +void CompressLogFiles() +{ + string path = GetNorthstarPrefix() + "/logs"; + for (const auto& entry : fs::directory_iterator(path)) + { + fs::path link = entry.path(); + string extension = link.extension().string(); + if (extension == ".txt" || extension == ".dmp") + { + compressFile(link); + } + } +} \ No newline at end of file diff --git a/NorthstarDedicatedTest/logCompression.h b/NorthstarDedicatedTest/logCompression.h new file mode 100644 index 00000000..39220c2e --- /dev/null +++ b/NorthstarDedicatedTest/logCompression.h @@ -0,0 +1,3 @@ +#pragma once + +void CompressLogFiles(); diff --git a/NorthstarDedicatedTest/logging.cpp b/NorthstarDedicatedTest/logging.cpp index ec46bedc..abedc035 100644 --- a/NorthstarDedicatedTest/logging.cpp +++ b/NorthstarDedicatedTest/logging.cpp @@ -10,10 +10,12 @@ #include #include #include "configurables.h" +#include "logCompression.h" // This needs to be called after hooks are loaded so we can access the command line args void CreateLogFiles() { + CompressLogFiles(); if (strstr(GetCommandLineA(), "-disablelogs")) { spdlog::default_logger()->set_level(spdlog::level::off);