1*01826a49SYabin Cui /*
2*01826a49SYabin Cui * Copyright (c) Meta Platforms, Inc. and affiliates.
3*01826a49SYabin Cui * All rights reserved.
4*01826a49SYabin Cui *
5*01826a49SYabin Cui * This source code is licensed under both the BSD-style license (found in the
6*01826a49SYabin Cui * LICENSE file in the root directory of this source tree) and the GPLv2 (found
7*01826a49SYabin Cui * in the COPYING file in the root directory of this source tree).
8*01826a49SYabin Cui * You may select, at your option, one of the above-listed licenses.
9*01826a49SYabin Cui */
10*01826a49SYabin Cui
11*01826a49SYabin Cui
12*01826a49SYabin Cui /* === Tuning parameters === */
13*01826a49SYabin Cui #ifndef ZWRAP_USE_ZSTD
14*01826a49SYabin Cui #define ZWRAP_USE_ZSTD 0
15*01826a49SYabin Cui #endif
16*01826a49SYabin Cui
17*01826a49SYabin Cui
18*01826a49SYabin Cui /* === Dependencies === */
19*01826a49SYabin Cui #include <stdlib.h>
20*01826a49SYabin Cui #include <stdio.h> /* vsprintf */
21*01826a49SYabin Cui #include <stdarg.h> /* va_list, for z_gzprintf */
22*01826a49SYabin Cui #include <string.h>
23*01826a49SYabin Cui #define NO_DUMMY_DECL
24*01826a49SYabin Cui #define ZLIB_CONST
25*01826a49SYabin Cui #include <zlib.h> /* without #define Z_PREFIX */
26*01826a49SYabin Cui #include "zstd_zlibwrapper.h"
27*01826a49SYabin Cui #define ZSTD_STATIC_LINKING_ONLY /* ZSTD_isFrame, ZSTD_MAGICNUMBER, ZSTD_customMem */
28*01826a49SYabin Cui #include "zstd.h"
29*01826a49SYabin Cui
30*01826a49SYabin Cui
31*01826a49SYabin Cui /* === Constants === */
32*01826a49SYabin Cui #define Z_INFLATE_SYNC 8
33*01826a49SYabin Cui #define ZLIB_HEADERSIZE 4
34*01826a49SYabin Cui #define ZSTD_HEADERSIZE ZSTD_FRAMEHEADERSIZE_MIN(ZSTD_f_zstd1)
35*01826a49SYabin Cui #define ZWRAP_DEFAULT_CLEVEL 3 /* Z_DEFAULT_COMPRESSION is translated to ZWRAP_DEFAULT_CLEVEL for zstd */
36*01826a49SYabin Cui
37*01826a49SYabin Cui
38*01826a49SYabin Cui /* === Debug === */
39*01826a49SYabin Cui #define LOG_WRAPPERC(...) /* fprintf(stderr, __VA_ARGS__) */
40*01826a49SYabin Cui #define LOG_WRAPPERD(...) /* fprintf(stderr, __VA_ARGS__) */
41*01826a49SYabin Cui
42*01826a49SYabin Cui #define FINISH_WITH_GZ_ERR(msg) { (void)msg; return Z_STREAM_ERROR; }
43*01826a49SYabin Cui #define FINISH_WITH_NULL_ERR(msg) { (void)msg; return NULL; }
44*01826a49SYabin Cui
45*01826a49SYabin Cui /* === Utility === */
46*01826a49SYabin Cui
47*01826a49SYabin Cui #define MIN(x,y) ((x) < (y) ? (x) : (y))
48*01826a49SYabin Cui
ZWRAP_isLittleEndian(void)49*01826a49SYabin Cui static unsigned ZWRAP_isLittleEndian(void)
50*01826a49SYabin Cui {
51*01826a49SYabin Cui const union { unsigned u; char c[4]; } one = { 1 }; /* don't use static : performance detrimental */
52*01826a49SYabin Cui return one.c[0];
53*01826a49SYabin Cui }
54*01826a49SYabin Cui
55*01826a49SYabin Cui #ifndef __has_builtin
56*01826a49SYabin Cui # define __has_builtin(x) 0
57*01826a49SYabin Cui #endif
58*01826a49SYabin Cui
ZWRAP_swap32(unsigned in)59*01826a49SYabin Cui static unsigned ZWRAP_swap32(unsigned in)
60*01826a49SYabin Cui {
61*01826a49SYabin Cui #if defined(_MSC_VER) /* Visual Studio */
62*01826a49SYabin Cui return _byteswap_ulong(in);
63*01826a49SYabin Cui #elif (defined (__GNUC__) && (__GNUC__ * 100 + __GNUC_MINOR__ >= 403)) \
64*01826a49SYabin Cui || (defined(__clang__) && __has_builtin(__builtin_bswap32))
65*01826a49SYabin Cui return __builtin_bswap32(in);
66*01826a49SYabin Cui #else
67*01826a49SYabin Cui return ((in << 24) & 0xff000000 ) |
68*01826a49SYabin Cui ((in << 8) & 0x00ff0000 ) |
69*01826a49SYabin Cui ((in >> 8) & 0x0000ff00 ) |
70*01826a49SYabin Cui ((in >> 24) & 0x000000ff );
71*01826a49SYabin Cui #endif
72*01826a49SYabin Cui }
73*01826a49SYabin Cui
ZWRAP_readLE32(const void * ptr)74*01826a49SYabin Cui static unsigned ZWRAP_readLE32(const void* ptr)
75*01826a49SYabin Cui {
76*01826a49SYabin Cui unsigned value;
77*01826a49SYabin Cui memcpy(&value, ptr, sizeof(value));
78*01826a49SYabin Cui if (ZWRAP_isLittleEndian())
79*01826a49SYabin Cui return value;
80*01826a49SYabin Cui else
81*01826a49SYabin Cui return ZWRAP_swap32(value);
82*01826a49SYabin Cui }
83*01826a49SYabin Cui
84*01826a49SYabin Cui
85*01826a49SYabin Cui /* === Wrapper === */
86*01826a49SYabin Cui static int g_ZWRAP_useZSTDcompression = ZWRAP_USE_ZSTD; /* 0 = don't use ZSTD */
87*01826a49SYabin Cui
ZWRAP_useZSTDcompression(int turn_on)88*01826a49SYabin Cui void ZWRAP_useZSTDcompression(int turn_on) { g_ZWRAP_useZSTDcompression = turn_on; }
89*01826a49SYabin Cui
ZWRAP_isUsingZSTDcompression(void)90*01826a49SYabin Cui int ZWRAP_isUsingZSTDcompression(void) { return g_ZWRAP_useZSTDcompression; }
91*01826a49SYabin Cui
92*01826a49SYabin Cui
93*01826a49SYabin Cui
94*01826a49SYabin Cui static ZWRAP_decompress_type g_ZWRAPdecompressionType = ZWRAP_AUTO;
95*01826a49SYabin Cui
ZWRAP_setDecompressionType(ZWRAP_decompress_type type)96*01826a49SYabin Cui void ZWRAP_setDecompressionType(ZWRAP_decompress_type type) { g_ZWRAPdecompressionType = type; }
97*01826a49SYabin Cui
ZWRAP_getDecompressionType(void)98*01826a49SYabin Cui ZWRAP_decompress_type ZWRAP_getDecompressionType(void) { return g_ZWRAPdecompressionType; }
99*01826a49SYabin Cui
100*01826a49SYabin Cui
101*01826a49SYabin Cui
zstdVersion(void)102*01826a49SYabin Cui const char * zstdVersion(void) { return ZSTD_VERSION_STRING; }
103*01826a49SYabin Cui
z_zlibVersion(void)104*01826a49SYabin Cui ZEXTERN const char * ZEXPORT z_zlibVersion _Z_OF((void)) { return zlibVersion(); }
105*01826a49SYabin Cui
ZWRAP_allocFunction(void * opaque,size_t size)106*01826a49SYabin Cui static void* ZWRAP_allocFunction(void* opaque, size_t size)
107*01826a49SYabin Cui {
108*01826a49SYabin Cui z_streamp strm = (z_streamp) opaque;
109*01826a49SYabin Cui void* address = strm->zalloc(strm->opaque, 1, (uInt)size);
110*01826a49SYabin Cui /* LOG_WRAPPERC("ZWRAP alloc %p, %d \n", address, (int)size); */
111*01826a49SYabin Cui return address;
112*01826a49SYabin Cui }
113*01826a49SYabin Cui
ZWRAP_freeFunction(void * opaque,void * address)114*01826a49SYabin Cui static void ZWRAP_freeFunction(void* opaque, void* address)
115*01826a49SYabin Cui {
116*01826a49SYabin Cui z_streamp strm = (z_streamp) opaque;
117*01826a49SYabin Cui strm->zfree(strm->opaque, address);
118*01826a49SYabin Cui /* if (address) LOG_WRAPPERC("ZWRAP free %p \n", address); */
119*01826a49SYabin Cui }
120*01826a49SYabin Cui
ZWRAP_customMalloc(size_t size,ZSTD_customMem customMem)121*01826a49SYabin Cui static void* ZWRAP_customMalloc(size_t size, ZSTD_customMem customMem)
122*01826a49SYabin Cui {
123*01826a49SYabin Cui if (customMem.customAlloc)
124*01826a49SYabin Cui return customMem.customAlloc(customMem.opaque, size);
125*01826a49SYabin Cui return malloc(size);
126*01826a49SYabin Cui }
127*01826a49SYabin Cui
ZWRAP_customCalloc(size_t size,ZSTD_customMem customMem)128*01826a49SYabin Cui static void* ZWRAP_customCalloc(size_t size, ZSTD_customMem customMem)
129*01826a49SYabin Cui {
130*01826a49SYabin Cui if (customMem.customAlloc) {
131*01826a49SYabin Cui /* calloc implemented as malloc+memset;
132*01826a49SYabin Cui * not as efficient as calloc, but next best guess for custom malloc */
133*01826a49SYabin Cui void* const ptr = customMem.customAlloc(customMem.opaque, size);
134*01826a49SYabin Cui memset(ptr, 0, size);
135*01826a49SYabin Cui return ptr;
136*01826a49SYabin Cui }
137*01826a49SYabin Cui return calloc(1, size);
138*01826a49SYabin Cui }
139*01826a49SYabin Cui
ZWRAP_customFree(void * ptr,ZSTD_customMem customMem)140*01826a49SYabin Cui static void ZWRAP_customFree(void* ptr, ZSTD_customMem customMem)
141*01826a49SYabin Cui {
142*01826a49SYabin Cui if (ptr!=NULL) {
143*01826a49SYabin Cui if (customMem.customFree)
144*01826a49SYabin Cui customMem.customFree(customMem.opaque, ptr);
145*01826a49SYabin Cui else
146*01826a49SYabin Cui free(ptr);
147*01826a49SYabin Cui }
148*01826a49SYabin Cui }
149*01826a49SYabin Cui
150*01826a49SYabin Cui
151*01826a49SYabin Cui
152*01826a49SYabin Cui /* === Compression === */
153*01826a49SYabin Cui typedef enum { ZWRAP_useInit, ZWRAP_useReset, ZWRAP_streamEnd } ZWRAP_state_t;
154*01826a49SYabin Cui
155*01826a49SYabin Cui typedef struct {
156*01826a49SYabin Cui ZSTD_CStream* zbc;
157*01826a49SYabin Cui int compressionLevel;
158*01826a49SYabin Cui int streamEnd; /* a flag to signal the end of a stream */
159*01826a49SYabin Cui unsigned long long totalInBytes; /* we need it as strm->total_in can be reset by user */
160*01826a49SYabin Cui ZSTD_customMem customMem;
161*01826a49SYabin Cui z_stream allocFunc; /* copy of zalloc, zfree, opaque */
162*01826a49SYabin Cui ZSTD_inBuffer inBuffer;
163*01826a49SYabin Cui ZSTD_outBuffer outBuffer;
164*01826a49SYabin Cui ZWRAP_state_t comprState;
165*01826a49SYabin Cui unsigned long long pledgedSrcSize;
166*01826a49SYabin Cui } ZWRAP_CCtx;
167*01826a49SYabin Cui
168*01826a49SYabin Cui /* typedef ZWRAP_CCtx internal_state; */
169*01826a49SYabin Cui
170*01826a49SYabin Cui
171*01826a49SYabin Cui
ZWRAP_freeCCtx(ZWRAP_CCtx * zwc)172*01826a49SYabin Cui static size_t ZWRAP_freeCCtx(ZWRAP_CCtx* zwc)
173*01826a49SYabin Cui {
174*01826a49SYabin Cui if (zwc==NULL) return 0; /* support free on NULL */
175*01826a49SYabin Cui ZSTD_freeCStream(zwc->zbc);
176*01826a49SYabin Cui ZWRAP_customFree(zwc, zwc->customMem);
177*01826a49SYabin Cui return 0;
178*01826a49SYabin Cui }
179*01826a49SYabin Cui
180*01826a49SYabin Cui
ZWRAP_createCCtx(z_streamp strm)181*01826a49SYabin Cui static ZWRAP_CCtx* ZWRAP_createCCtx(z_streamp strm)
182*01826a49SYabin Cui {
183*01826a49SYabin Cui ZWRAP_CCtx* zwc;
184*01826a49SYabin Cui ZSTD_customMem customMem = { NULL, NULL, NULL };
185*01826a49SYabin Cui
186*01826a49SYabin Cui if (strm->zalloc && strm->zfree) {
187*01826a49SYabin Cui customMem.customAlloc = ZWRAP_allocFunction;
188*01826a49SYabin Cui customMem.customFree = ZWRAP_freeFunction;
189*01826a49SYabin Cui }
190*01826a49SYabin Cui customMem.opaque = strm;
191*01826a49SYabin Cui
192*01826a49SYabin Cui zwc = (ZWRAP_CCtx*)ZWRAP_customCalloc(sizeof(ZWRAP_CCtx), customMem);
193*01826a49SYabin Cui if (zwc == NULL) return NULL;
194*01826a49SYabin Cui zwc->allocFunc = *strm;
195*01826a49SYabin Cui customMem.opaque = &zwc->allocFunc;
196*01826a49SYabin Cui zwc->customMem = customMem;
197*01826a49SYabin Cui
198*01826a49SYabin Cui return zwc;
199*01826a49SYabin Cui }
200*01826a49SYabin Cui
201*01826a49SYabin Cui
ZWRAP_initializeCStream(ZWRAP_CCtx * zwc,const void * dict,size_t dictSize,unsigned long long pledgedSrcSize)202*01826a49SYabin Cui static int ZWRAP_initializeCStream(ZWRAP_CCtx* zwc, const void* dict, size_t dictSize, unsigned long long pledgedSrcSize)
203*01826a49SYabin Cui {
204*01826a49SYabin Cui LOG_WRAPPERC("- ZWRAP_initializeCStream=%p\n", zwc);
205*01826a49SYabin Cui if (zwc == NULL || zwc->zbc == NULL) return Z_STREAM_ERROR;
206*01826a49SYabin Cui
207*01826a49SYabin Cui if (!pledgedSrcSize) pledgedSrcSize = zwc->pledgedSrcSize;
208*01826a49SYabin Cui { unsigned initErr = 0;
209*01826a49SYabin Cui ZSTD_parameters const params = ZSTD_getParams(zwc->compressionLevel, pledgedSrcSize, dictSize);
210*01826a49SYabin Cui ZSTD_CCtx_params* cctxParams = ZSTD_createCCtxParams();
211*01826a49SYabin Cui if (!cctxParams) return Z_STREAM_ERROR;
212*01826a49SYabin Cui LOG_WRAPPERC("pledgedSrcSize=%d windowLog=%d chainLog=%d hashLog=%d searchLog=%d minMatch=%d strategy=%d\n",
213*01826a49SYabin Cui (int)pledgedSrcSize, params.cParams.windowLog, params.cParams.chainLog, params.cParams.hashLog, params.cParams.searchLog, params.cParams.minMatch, params.cParams.strategy);
214*01826a49SYabin Cui
215*01826a49SYabin Cui initErr |= ZSTD_isError(ZSTD_CCtx_reset(zwc->zbc, ZSTD_reset_session_only));
216*01826a49SYabin Cui initErr |= ZSTD_isError(ZSTD_CCtxParams_init_advanced(cctxParams, params));
217*01826a49SYabin Cui initErr |= ZSTD_isError(ZSTD_CCtx_setParametersUsingCCtxParams(zwc->zbc, cctxParams));
218*01826a49SYabin Cui initErr |= ZSTD_isError(ZSTD_CCtx_setPledgedSrcSize(zwc->zbc, pledgedSrcSize));
219*01826a49SYabin Cui initErr |= ZSTD_isError(ZSTD_CCtx_loadDictionary(zwc->zbc, dict, dictSize));
220*01826a49SYabin Cui
221*01826a49SYabin Cui ZSTD_freeCCtxParams(cctxParams);
222*01826a49SYabin Cui if (initErr) return Z_STREAM_ERROR;
223*01826a49SYabin Cui }
224*01826a49SYabin Cui
225*01826a49SYabin Cui return Z_OK;
226*01826a49SYabin Cui }
227*01826a49SYabin Cui
228*01826a49SYabin Cui
ZWRAPC_finishWithError(ZWRAP_CCtx * zwc,z_streamp strm,int error)229*01826a49SYabin Cui static int ZWRAPC_finishWithError(ZWRAP_CCtx* zwc, z_streamp strm, int error)
230*01826a49SYabin Cui {
231*01826a49SYabin Cui LOG_WRAPPERC("- ZWRAPC_finishWithError=%d\n", error);
232*01826a49SYabin Cui if (zwc) ZWRAP_freeCCtx(zwc);
233*01826a49SYabin Cui if (strm) strm->state = NULL;
234*01826a49SYabin Cui return (error) ? error : Z_STREAM_ERROR;
235*01826a49SYabin Cui }
236*01826a49SYabin Cui
237*01826a49SYabin Cui
ZWRAPC_finishWithErrorMsg(z_streamp strm,char * message)238*01826a49SYabin Cui static int ZWRAPC_finishWithErrorMsg(z_streamp strm, char* message)
239*01826a49SYabin Cui {
240*01826a49SYabin Cui ZWRAP_CCtx* zwc = (ZWRAP_CCtx*) strm->state;
241*01826a49SYabin Cui strm->msg = message;
242*01826a49SYabin Cui if (zwc == NULL) return Z_STREAM_ERROR;
243*01826a49SYabin Cui
244*01826a49SYabin Cui return ZWRAPC_finishWithError(zwc, strm, 0);
245*01826a49SYabin Cui }
246*01826a49SYabin Cui
247*01826a49SYabin Cui
ZWRAP_setPledgedSrcSize(z_streamp strm,unsigned long long pledgedSrcSize)248*01826a49SYabin Cui int ZWRAP_setPledgedSrcSize(z_streamp strm, unsigned long long pledgedSrcSize)
249*01826a49SYabin Cui {
250*01826a49SYabin Cui ZWRAP_CCtx* zwc = (ZWRAP_CCtx*) strm->state;
251*01826a49SYabin Cui if (zwc == NULL) return Z_STREAM_ERROR;
252*01826a49SYabin Cui
253*01826a49SYabin Cui zwc->pledgedSrcSize = pledgedSrcSize;
254*01826a49SYabin Cui zwc->comprState = ZWRAP_useInit;
255*01826a49SYabin Cui return Z_OK;
256*01826a49SYabin Cui }
257*01826a49SYabin Cui
convert_into_sis(void * ptr)258*01826a49SYabin Cui static struct internal_state* convert_into_sis(void* ptr)
259*01826a49SYabin Cui {
260*01826a49SYabin Cui return (struct internal_state*) ptr;
261*01826a49SYabin Cui }
262*01826a49SYabin Cui
z_deflateInit_(z_streamp strm,int level,const char * version,int stream_size)263*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateInit_ _Z_OF((z_streamp strm, int level,
264*01826a49SYabin Cui const char *version, int stream_size))
265*01826a49SYabin Cui {
266*01826a49SYabin Cui ZWRAP_CCtx* zwc;
267*01826a49SYabin Cui
268*01826a49SYabin Cui LOG_WRAPPERC("- deflateInit level=%d\n", level);
269*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression) {
270*01826a49SYabin Cui return deflateInit_((strm), (level), version, stream_size);
271*01826a49SYabin Cui }
272*01826a49SYabin Cui
273*01826a49SYabin Cui zwc = ZWRAP_createCCtx(strm);
274*01826a49SYabin Cui if (zwc == NULL) return Z_MEM_ERROR;
275*01826a49SYabin Cui
276*01826a49SYabin Cui if (level == Z_DEFAULT_COMPRESSION)
277*01826a49SYabin Cui level = ZWRAP_DEFAULT_CLEVEL;
278*01826a49SYabin Cui
279*01826a49SYabin Cui zwc->streamEnd = 0;
280*01826a49SYabin Cui zwc->totalInBytes = 0;
281*01826a49SYabin Cui zwc->compressionLevel = level;
282*01826a49SYabin Cui strm->state = convert_into_sis(zwc); /* use state which in not used by user */
283*01826a49SYabin Cui strm->total_in = 0;
284*01826a49SYabin Cui strm->total_out = 0;
285*01826a49SYabin Cui strm->adler = 0;
286*01826a49SYabin Cui return Z_OK;
287*01826a49SYabin Cui }
288*01826a49SYabin Cui
289*01826a49SYabin Cui
z_deflateInit2_(z_streamp strm,int level,int method,int windowBits,int memLevel,int strategy,const char * version,int stream_size)290*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateInit2_ _Z_OF((z_streamp strm, int level, int method,
291*01826a49SYabin Cui int windowBits, int memLevel,
292*01826a49SYabin Cui int strategy, const char *version,
293*01826a49SYabin Cui int stream_size))
294*01826a49SYabin Cui {
295*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
296*01826a49SYabin Cui return deflateInit2_(strm, level, method, windowBits, memLevel, strategy, version, stream_size);
297*01826a49SYabin Cui
298*01826a49SYabin Cui return z_deflateInit_ (strm, level, version, stream_size);
299*01826a49SYabin Cui }
300*01826a49SYabin Cui
301*01826a49SYabin Cui
ZWRAP_deflateReset_keepDict(z_streamp strm)302*01826a49SYabin Cui int ZWRAP_deflateReset_keepDict(z_streamp strm)
303*01826a49SYabin Cui {
304*01826a49SYabin Cui LOG_WRAPPERC("- ZWRAP_deflateReset_keepDict\n");
305*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
306*01826a49SYabin Cui return deflateReset(strm);
307*01826a49SYabin Cui
308*01826a49SYabin Cui { ZWRAP_CCtx* zwc = (ZWRAP_CCtx*) strm->state;
309*01826a49SYabin Cui if (zwc) {
310*01826a49SYabin Cui zwc->streamEnd = 0;
311*01826a49SYabin Cui zwc->totalInBytes = 0;
312*01826a49SYabin Cui }
313*01826a49SYabin Cui }
314*01826a49SYabin Cui
315*01826a49SYabin Cui strm->total_in = 0;
316*01826a49SYabin Cui strm->total_out = 0;
317*01826a49SYabin Cui strm->adler = 0;
318*01826a49SYabin Cui return Z_OK;
319*01826a49SYabin Cui }
320*01826a49SYabin Cui
321*01826a49SYabin Cui
z_deflateReset(z_streamp strm)322*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateReset _Z_OF((z_streamp strm))
323*01826a49SYabin Cui {
324*01826a49SYabin Cui LOG_WRAPPERC("- deflateReset\n");
325*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
326*01826a49SYabin Cui return deflateReset(strm);
327*01826a49SYabin Cui
328*01826a49SYabin Cui ZWRAP_deflateReset_keepDict(strm);
329*01826a49SYabin Cui
330*01826a49SYabin Cui { ZWRAP_CCtx* zwc = (ZWRAP_CCtx*) strm->state;
331*01826a49SYabin Cui if (zwc) zwc->comprState = ZWRAP_useInit;
332*01826a49SYabin Cui }
333*01826a49SYabin Cui return Z_OK;
334*01826a49SYabin Cui }
335*01826a49SYabin Cui
336*01826a49SYabin Cui
z_deflateSetDictionary(z_streamp strm,const Bytef * dictionary,uInt dictLength)337*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateSetDictionary _Z_OF((z_streamp strm,
338*01826a49SYabin Cui const Bytef *dictionary,
339*01826a49SYabin Cui uInt dictLength))
340*01826a49SYabin Cui {
341*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression) {
342*01826a49SYabin Cui LOG_WRAPPERC("- deflateSetDictionary\n");
343*01826a49SYabin Cui return deflateSetDictionary(strm, dictionary, dictLength);
344*01826a49SYabin Cui }
345*01826a49SYabin Cui
346*01826a49SYabin Cui { ZWRAP_CCtx* zwc = (ZWRAP_CCtx*) strm->state;
347*01826a49SYabin Cui LOG_WRAPPERC("- deflateSetDictionary level=%d\n", (int)zwc->compressionLevel);
348*01826a49SYabin Cui if (!zwc) return Z_STREAM_ERROR;
349*01826a49SYabin Cui if (zwc->zbc == NULL) {
350*01826a49SYabin Cui zwc->zbc = ZSTD_createCStream_advanced(zwc->customMem);
351*01826a49SYabin Cui if (zwc->zbc == NULL) return ZWRAPC_finishWithError(zwc, strm, 0);
352*01826a49SYabin Cui }
353*01826a49SYabin Cui { int res = ZWRAP_initializeCStream(zwc, dictionary, dictLength, ZSTD_CONTENTSIZE_UNKNOWN);
354*01826a49SYabin Cui if (res != Z_OK) return ZWRAPC_finishWithError(zwc, strm, res); }
355*01826a49SYabin Cui zwc->comprState = ZWRAP_useReset;
356*01826a49SYabin Cui }
357*01826a49SYabin Cui
358*01826a49SYabin Cui return Z_OK;
359*01826a49SYabin Cui }
360*01826a49SYabin Cui
361*01826a49SYabin Cui
z_deflate(z_streamp strm,int flush)362*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflate _Z_OF((z_streamp strm, int flush))
363*01826a49SYabin Cui {
364*01826a49SYabin Cui ZWRAP_CCtx* zwc;
365*01826a49SYabin Cui
366*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression) {
367*01826a49SYabin Cui LOG_WRAPPERC("- deflate1 flush=%d avail_in=%d avail_out=%d total_in=%d total_out=%d\n",
368*01826a49SYabin Cui (int)flush, (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out);
369*01826a49SYabin Cui return deflate(strm, flush);
370*01826a49SYabin Cui }
371*01826a49SYabin Cui
372*01826a49SYabin Cui zwc = (ZWRAP_CCtx*) strm->state;
373*01826a49SYabin Cui if (zwc == NULL) { LOG_WRAPPERC("zwc == NULL\n"); return Z_STREAM_ERROR; }
374*01826a49SYabin Cui
375*01826a49SYabin Cui if (zwc->zbc == NULL) {
376*01826a49SYabin Cui zwc->zbc = ZSTD_createCStream_advanced(zwc->customMem);
377*01826a49SYabin Cui if (zwc->zbc == NULL) return ZWRAPC_finishWithError(zwc, strm, 0);
378*01826a49SYabin Cui { int const initErr = ZWRAP_initializeCStream(zwc, NULL, 0, (flush == Z_FINISH) ? strm->avail_in : ZSTD_CONTENTSIZE_UNKNOWN);
379*01826a49SYabin Cui if (initErr != Z_OK) return ZWRAPC_finishWithError(zwc, strm, initErr); }
380*01826a49SYabin Cui if (flush != Z_FINISH) zwc->comprState = ZWRAP_useReset;
381*01826a49SYabin Cui } else {
382*01826a49SYabin Cui if (zwc->totalInBytes == 0) {
383*01826a49SYabin Cui if (zwc->comprState == ZWRAP_useReset) {
384*01826a49SYabin Cui size_t resetErr = ZSTD_CCtx_reset(zwc->zbc, ZSTD_reset_session_only);
385*01826a49SYabin Cui if (ZSTD_isError(resetErr)) {
386*01826a49SYabin Cui LOG_WRAPPERC("ERROR: ZSTD_CCtx_reset errorCode=%s\n",
387*01826a49SYabin Cui ZSTD_getErrorName(resetErr));
388*01826a49SYabin Cui return ZWRAPC_finishWithError(zwc, strm, 0);
389*01826a49SYabin Cui }
390*01826a49SYabin Cui resetErr = ZSTD_CCtx_setPledgedSrcSize(zwc->zbc, (flush == Z_FINISH) ? strm->avail_in : zwc->pledgedSrcSize);
391*01826a49SYabin Cui if (ZSTD_isError(resetErr)) {
392*01826a49SYabin Cui LOG_WRAPPERC("ERROR: ZSTD_CCtx_setPledgedSrcSize errorCode=%s\n",
393*01826a49SYabin Cui ZSTD_getErrorName(resetErr));
394*01826a49SYabin Cui return ZWRAPC_finishWithError(zwc, strm, 0);
395*01826a49SYabin Cui }
396*01826a49SYabin Cui } else {
397*01826a49SYabin Cui int const res = ZWRAP_initializeCStream(zwc, NULL, 0, (flush == Z_FINISH) ? strm->avail_in : ZSTD_CONTENTSIZE_UNKNOWN);
398*01826a49SYabin Cui if (res != Z_OK) return ZWRAPC_finishWithError(zwc, strm, res);
399*01826a49SYabin Cui if (flush != Z_FINISH) zwc->comprState = ZWRAP_useReset;
400*01826a49SYabin Cui }
401*01826a49SYabin Cui } /* (zwc->totalInBytes == 0) */
402*01826a49SYabin Cui } /* ! (zwc->zbc == NULL) */
403*01826a49SYabin Cui
404*01826a49SYabin Cui LOG_WRAPPERC("- deflate2 flush=%d avail_in=%d avail_out=%d total_in=%d total_out=%d\n", (int)flush, (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out);
405*01826a49SYabin Cui if (strm->avail_in > 0) {
406*01826a49SYabin Cui zwc->inBuffer.src = strm->next_in;
407*01826a49SYabin Cui zwc->inBuffer.size = strm->avail_in;
408*01826a49SYabin Cui zwc->inBuffer.pos = 0;
409*01826a49SYabin Cui zwc->outBuffer.dst = strm->next_out;
410*01826a49SYabin Cui zwc->outBuffer.size = strm->avail_out;
411*01826a49SYabin Cui zwc->outBuffer.pos = 0;
412*01826a49SYabin Cui { size_t const cErr = ZSTD_compressStream(zwc->zbc, &zwc->outBuffer, &zwc->inBuffer);
413*01826a49SYabin Cui LOG_WRAPPERC("deflate ZSTD_compressStream srcSize=%d dstCapacity=%d\n", (int)zwc->inBuffer.size, (int)zwc->outBuffer.size);
414*01826a49SYabin Cui if (ZSTD_isError(cErr)) return ZWRAPC_finishWithError(zwc, strm, 0);
415*01826a49SYabin Cui }
416*01826a49SYabin Cui strm->next_out += zwc->outBuffer.pos;
417*01826a49SYabin Cui strm->total_out += zwc->outBuffer.pos;
418*01826a49SYabin Cui strm->avail_out -= zwc->outBuffer.pos;
419*01826a49SYabin Cui strm->total_in += zwc->inBuffer.pos;
420*01826a49SYabin Cui zwc->totalInBytes += zwc->inBuffer.pos;
421*01826a49SYabin Cui strm->next_in += zwc->inBuffer.pos;
422*01826a49SYabin Cui strm->avail_in -= zwc->inBuffer.pos;
423*01826a49SYabin Cui }
424*01826a49SYabin Cui
425*01826a49SYabin Cui if (flush == Z_FULL_FLUSH
426*01826a49SYabin Cui #if ZLIB_VERNUM >= 0x1240
427*01826a49SYabin Cui || flush == Z_TREES
428*01826a49SYabin Cui #endif
429*01826a49SYabin Cui || flush == Z_BLOCK)
430*01826a49SYabin Cui return ZWRAPC_finishWithErrorMsg(strm, "Z_FULL_FLUSH, Z_BLOCK and Z_TREES are not supported!");
431*01826a49SYabin Cui
432*01826a49SYabin Cui if (flush == Z_FINISH) {
433*01826a49SYabin Cui size_t bytesLeft;
434*01826a49SYabin Cui if (zwc->streamEnd) return Z_STREAM_END;
435*01826a49SYabin Cui zwc->outBuffer.dst = strm->next_out;
436*01826a49SYabin Cui zwc->outBuffer.size = strm->avail_out;
437*01826a49SYabin Cui zwc->outBuffer.pos = 0;
438*01826a49SYabin Cui bytesLeft = ZSTD_endStream(zwc->zbc, &zwc->outBuffer);
439*01826a49SYabin Cui LOG_WRAPPERC("deflate ZSTD_endStream dstCapacity=%d bytesLeft=%d\n", (int)strm->avail_out, (int)bytesLeft);
440*01826a49SYabin Cui if (ZSTD_isError(bytesLeft)) return ZWRAPC_finishWithError(zwc, strm, 0);
441*01826a49SYabin Cui strm->next_out += zwc->outBuffer.pos;
442*01826a49SYabin Cui strm->total_out += zwc->outBuffer.pos;
443*01826a49SYabin Cui strm->avail_out -= zwc->outBuffer.pos;
444*01826a49SYabin Cui if (bytesLeft == 0) {
445*01826a49SYabin Cui zwc->streamEnd = 1;
446*01826a49SYabin Cui LOG_WRAPPERC("Z_STREAM_END2 strm->total_in=%d strm->avail_out=%d strm->total_out=%d\n",
447*01826a49SYabin Cui (int)strm->total_in, (int)strm->avail_out, (int)strm->total_out);
448*01826a49SYabin Cui return Z_STREAM_END;
449*01826a49SYabin Cui } }
450*01826a49SYabin Cui else
451*01826a49SYabin Cui if (flush == Z_SYNC_FLUSH || flush == Z_PARTIAL_FLUSH) {
452*01826a49SYabin Cui size_t bytesLeft;
453*01826a49SYabin Cui zwc->outBuffer.dst = strm->next_out;
454*01826a49SYabin Cui zwc->outBuffer.size = strm->avail_out;
455*01826a49SYabin Cui zwc->outBuffer.pos = 0;
456*01826a49SYabin Cui bytesLeft = ZSTD_flushStream(zwc->zbc, &zwc->outBuffer);
457*01826a49SYabin Cui LOG_WRAPPERC("deflate ZSTD_flushStream dstCapacity=%d bytesLeft=%d\n", (int)strm->avail_out, (int)bytesLeft);
458*01826a49SYabin Cui if (ZSTD_isError(bytesLeft)) return ZWRAPC_finishWithError(zwc, strm, 0);
459*01826a49SYabin Cui strm->next_out += zwc->outBuffer.pos;
460*01826a49SYabin Cui strm->total_out += zwc->outBuffer.pos;
461*01826a49SYabin Cui strm->avail_out -= zwc->outBuffer.pos;
462*01826a49SYabin Cui }
463*01826a49SYabin Cui LOG_WRAPPERC("- deflate3 flush=%d avail_in=%d avail_out=%d total_in=%d total_out=%d\n", (int)flush, (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out);
464*01826a49SYabin Cui return Z_OK;
465*01826a49SYabin Cui }
466*01826a49SYabin Cui
467*01826a49SYabin Cui
z_deflateEnd(z_streamp strm)468*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateEnd _Z_OF((z_streamp strm))
469*01826a49SYabin Cui {
470*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression) {
471*01826a49SYabin Cui LOG_WRAPPERC("- deflateEnd\n");
472*01826a49SYabin Cui return deflateEnd(strm);
473*01826a49SYabin Cui }
474*01826a49SYabin Cui LOG_WRAPPERC("- deflateEnd total_in=%d total_out=%d\n", (int)(strm->total_in), (int)(strm->total_out));
475*01826a49SYabin Cui { size_t errorCode;
476*01826a49SYabin Cui ZWRAP_CCtx* zwc = (ZWRAP_CCtx*) strm->state;
477*01826a49SYabin Cui if (zwc == NULL) return Z_OK; /* structures are already freed */
478*01826a49SYabin Cui strm->state = NULL;
479*01826a49SYabin Cui errorCode = ZWRAP_freeCCtx(zwc);
480*01826a49SYabin Cui if (ZSTD_isError(errorCode)) return Z_STREAM_ERROR;
481*01826a49SYabin Cui }
482*01826a49SYabin Cui return Z_OK;
483*01826a49SYabin Cui }
484*01826a49SYabin Cui
485*01826a49SYabin Cui
z_deflateBound(z_streamp strm,uLong sourceLen)486*01826a49SYabin Cui ZEXTERN uLong ZEXPORT z_deflateBound _Z_OF((z_streamp strm,
487*01826a49SYabin Cui uLong sourceLen))
488*01826a49SYabin Cui {
489*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
490*01826a49SYabin Cui return deflateBound(strm, sourceLen);
491*01826a49SYabin Cui
492*01826a49SYabin Cui return ZSTD_compressBound(sourceLen);
493*01826a49SYabin Cui }
494*01826a49SYabin Cui
495*01826a49SYabin Cui
z_deflateParams(z_streamp strm,int level,int strategy)496*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateParams _Z_OF((z_streamp strm,
497*01826a49SYabin Cui int level,
498*01826a49SYabin Cui int strategy))
499*01826a49SYabin Cui {
500*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression) {
501*01826a49SYabin Cui LOG_WRAPPERC("- deflateParams level=%d strategy=%d\n", level, strategy);
502*01826a49SYabin Cui return deflateParams(strm, level, strategy);
503*01826a49SYabin Cui }
504*01826a49SYabin Cui
505*01826a49SYabin Cui return Z_OK;
506*01826a49SYabin Cui }
507*01826a49SYabin Cui
508*01826a49SYabin Cui
509*01826a49SYabin Cui
510*01826a49SYabin Cui
511*01826a49SYabin Cui
512*01826a49SYabin Cui /* === Decompression === */
513*01826a49SYabin Cui
514*01826a49SYabin Cui typedef enum { ZWRAP_ZLIB_STREAM, ZWRAP_ZSTD_STREAM, ZWRAP_UNKNOWN_STREAM } ZWRAP_stream_type;
515*01826a49SYabin Cui
516*01826a49SYabin Cui typedef struct {
517*01826a49SYabin Cui ZSTD_DStream* zbd;
518*01826a49SYabin Cui char headerBuf[16]; /* must be >= ZSTD_frameHeaderSize_min */
519*01826a49SYabin Cui int errorCount;
520*01826a49SYabin Cui unsigned long long totalInBytes; /* we need it as strm->total_in can be reset by user */
521*01826a49SYabin Cui ZWRAP_state_t decompState;
522*01826a49SYabin Cui ZSTD_inBuffer inBuffer;
523*01826a49SYabin Cui ZSTD_outBuffer outBuffer;
524*01826a49SYabin Cui
525*01826a49SYabin Cui /* zlib params */
526*01826a49SYabin Cui int stream_size;
527*01826a49SYabin Cui char *version;
528*01826a49SYabin Cui int windowBits;
529*01826a49SYabin Cui ZSTD_customMem customMem;
530*01826a49SYabin Cui z_stream allocFunc; /* just to copy zalloc, zfree, opaque */
531*01826a49SYabin Cui } ZWRAP_DCtx;
532*01826a49SYabin Cui
533*01826a49SYabin Cui
ZWRAP_initDCtx(ZWRAP_DCtx * zwd)534*01826a49SYabin Cui static void ZWRAP_initDCtx(ZWRAP_DCtx* zwd)
535*01826a49SYabin Cui {
536*01826a49SYabin Cui zwd->errorCount = 0;
537*01826a49SYabin Cui zwd->outBuffer.pos = 0;
538*01826a49SYabin Cui zwd->outBuffer.size = 0;
539*01826a49SYabin Cui }
540*01826a49SYabin Cui
ZWRAP_createDCtx(z_streamp strm)541*01826a49SYabin Cui static ZWRAP_DCtx* ZWRAP_createDCtx(z_streamp strm)
542*01826a49SYabin Cui {
543*01826a49SYabin Cui ZWRAP_DCtx* zwd;
544*01826a49SYabin Cui ZSTD_customMem customMem = { NULL, NULL, NULL };
545*01826a49SYabin Cui
546*01826a49SYabin Cui if (strm->zalloc && strm->zfree) {
547*01826a49SYabin Cui customMem.customAlloc = ZWRAP_allocFunction;
548*01826a49SYabin Cui customMem.customFree = ZWRAP_freeFunction;
549*01826a49SYabin Cui }
550*01826a49SYabin Cui customMem.opaque = strm;
551*01826a49SYabin Cui
552*01826a49SYabin Cui zwd = (ZWRAP_DCtx*)ZWRAP_customCalloc(sizeof(ZWRAP_DCtx), customMem);
553*01826a49SYabin Cui if (zwd == NULL) return NULL;
554*01826a49SYabin Cui zwd->allocFunc = *strm;
555*01826a49SYabin Cui customMem.opaque = &zwd->allocFunc;
556*01826a49SYabin Cui zwd->customMem = customMem;
557*01826a49SYabin Cui
558*01826a49SYabin Cui ZWRAP_initDCtx(zwd);
559*01826a49SYabin Cui return zwd;
560*01826a49SYabin Cui }
561*01826a49SYabin Cui
ZWRAP_freeDCtx(ZWRAP_DCtx * zwd)562*01826a49SYabin Cui static size_t ZWRAP_freeDCtx(ZWRAP_DCtx* zwd)
563*01826a49SYabin Cui {
564*01826a49SYabin Cui if (zwd==NULL) return 0; /* support free on null */
565*01826a49SYabin Cui ZSTD_freeDStream(zwd->zbd);
566*01826a49SYabin Cui ZWRAP_customFree(zwd->version, zwd->customMem);
567*01826a49SYabin Cui ZWRAP_customFree(zwd, zwd->customMem);
568*01826a49SYabin Cui return 0;
569*01826a49SYabin Cui }
570*01826a49SYabin Cui
571*01826a49SYabin Cui
ZWRAP_isUsingZSTDdecompression(z_streamp strm)572*01826a49SYabin Cui int ZWRAP_isUsingZSTDdecompression(z_streamp strm)
573*01826a49SYabin Cui {
574*01826a49SYabin Cui if (strm == NULL) return 0;
575*01826a49SYabin Cui return (strm->reserved == ZWRAP_ZSTD_STREAM);
576*01826a49SYabin Cui }
577*01826a49SYabin Cui
578*01826a49SYabin Cui
ZWRAPD_finishWithError(ZWRAP_DCtx * zwd,z_streamp strm,int error)579*01826a49SYabin Cui static int ZWRAPD_finishWithError(ZWRAP_DCtx* zwd, z_streamp strm, int error)
580*01826a49SYabin Cui {
581*01826a49SYabin Cui LOG_WRAPPERD("- ZWRAPD_finishWithError=%d\n", error);
582*01826a49SYabin Cui ZWRAP_freeDCtx(zwd);
583*01826a49SYabin Cui strm->state = NULL;
584*01826a49SYabin Cui return (error) ? error : Z_STREAM_ERROR;
585*01826a49SYabin Cui }
586*01826a49SYabin Cui
ZWRAPD_finishWithErrorMsg(z_streamp strm,char * message)587*01826a49SYabin Cui static int ZWRAPD_finishWithErrorMsg(z_streamp strm, char* message)
588*01826a49SYabin Cui {
589*01826a49SYabin Cui ZWRAP_DCtx* const zwd = (ZWRAP_DCtx*) strm->state;
590*01826a49SYabin Cui strm->msg = message;
591*01826a49SYabin Cui if (zwd == NULL) return Z_STREAM_ERROR;
592*01826a49SYabin Cui
593*01826a49SYabin Cui return ZWRAPD_finishWithError(zwd, strm, 0);
594*01826a49SYabin Cui }
595*01826a49SYabin Cui
596*01826a49SYabin Cui
z_inflateInit_(z_streamp strm,const char * version,int stream_size)597*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateInit_ _Z_OF((z_streamp strm,
598*01826a49SYabin Cui const char* version, int stream_size))
599*01826a49SYabin Cui {
600*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB) {
601*01826a49SYabin Cui strm->reserved = ZWRAP_ZLIB_STREAM;
602*01826a49SYabin Cui return inflateInit(strm);
603*01826a49SYabin Cui }
604*01826a49SYabin Cui
605*01826a49SYabin Cui { ZWRAP_DCtx* const zwd = ZWRAP_createDCtx(strm);
606*01826a49SYabin Cui LOG_WRAPPERD("- inflateInit\n");
607*01826a49SYabin Cui if (zwd == NULL) return ZWRAPD_finishWithError(zwd, strm, 0);
608*01826a49SYabin Cui
609*01826a49SYabin Cui zwd->version = (char*)ZWRAP_customMalloc(strlen(version)+1, zwd->customMem);
610*01826a49SYabin Cui if (zwd->version == NULL) return ZWRAPD_finishWithError(zwd, strm, 0);
611*01826a49SYabin Cui strcpy(zwd->version, version);
612*01826a49SYabin Cui
613*01826a49SYabin Cui zwd->stream_size = stream_size;
614*01826a49SYabin Cui zwd->totalInBytes = 0;
615*01826a49SYabin Cui strm->state = convert_into_sis(zwd);
616*01826a49SYabin Cui strm->total_in = 0;
617*01826a49SYabin Cui strm->total_out = 0;
618*01826a49SYabin Cui strm->reserved = ZWRAP_UNKNOWN_STREAM;
619*01826a49SYabin Cui strm->adler = 0;
620*01826a49SYabin Cui }
621*01826a49SYabin Cui
622*01826a49SYabin Cui return Z_OK;
623*01826a49SYabin Cui }
624*01826a49SYabin Cui
625*01826a49SYabin Cui
z_inflateInit2_(z_streamp strm,int windowBits,const char * version,int stream_size)626*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateInit2_ _Z_OF((z_streamp strm, int windowBits,
627*01826a49SYabin Cui const char *version, int stream_size))
628*01826a49SYabin Cui {
629*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB) {
630*01826a49SYabin Cui return inflateInit2_(strm, windowBits, version, stream_size);
631*01826a49SYabin Cui }
632*01826a49SYabin Cui
633*01826a49SYabin Cui { int const ret = z_inflateInit_ (strm, version, stream_size);
634*01826a49SYabin Cui LOG_WRAPPERD("- inflateInit2 windowBits=%d\n", windowBits);
635*01826a49SYabin Cui if (ret == Z_OK) {
636*01826a49SYabin Cui ZWRAP_DCtx* const zwd = (ZWRAP_DCtx*)strm->state;
637*01826a49SYabin Cui if (zwd == NULL) return Z_STREAM_ERROR;
638*01826a49SYabin Cui zwd->windowBits = windowBits;
639*01826a49SYabin Cui }
640*01826a49SYabin Cui return ret;
641*01826a49SYabin Cui }
642*01826a49SYabin Cui }
643*01826a49SYabin Cui
ZWRAP_inflateReset_keepDict(z_streamp strm)644*01826a49SYabin Cui int ZWRAP_inflateReset_keepDict(z_streamp strm)
645*01826a49SYabin Cui {
646*01826a49SYabin Cui LOG_WRAPPERD("- ZWRAP_inflateReset_keepDict\n");
647*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
648*01826a49SYabin Cui return inflateReset(strm);
649*01826a49SYabin Cui
650*01826a49SYabin Cui { ZWRAP_DCtx* const zwd = (ZWRAP_DCtx*) strm->state;
651*01826a49SYabin Cui if (zwd == NULL) return Z_STREAM_ERROR;
652*01826a49SYabin Cui ZWRAP_initDCtx(zwd);
653*01826a49SYabin Cui zwd->decompState = ZWRAP_useReset;
654*01826a49SYabin Cui zwd->totalInBytes = 0;
655*01826a49SYabin Cui }
656*01826a49SYabin Cui
657*01826a49SYabin Cui strm->total_in = 0;
658*01826a49SYabin Cui strm->total_out = 0;
659*01826a49SYabin Cui return Z_OK;
660*01826a49SYabin Cui }
661*01826a49SYabin Cui
662*01826a49SYabin Cui
z_inflateReset(z_streamp strm)663*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateReset _Z_OF((z_streamp strm))
664*01826a49SYabin Cui {
665*01826a49SYabin Cui LOG_WRAPPERD("- inflateReset\n");
666*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
667*01826a49SYabin Cui return inflateReset(strm);
668*01826a49SYabin Cui
669*01826a49SYabin Cui { int const ret = ZWRAP_inflateReset_keepDict(strm);
670*01826a49SYabin Cui if (ret != Z_OK) return ret; }
671*01826a49SYabin Cui
672*01826a49SYabin Cui { ZWRAP_DCtx* const zwd = (ZWRAP_DCtx*) strm->state;
673*01826a49SYabin Cui if (zwd == NULL) return Z_STREAM_ERROR;
674*01826a49SYabin Cui zwd->decompState = ZWRAP_useInit; }
675*01826a49SYabin Cui
676*01826a49SYabin Cui return Z_OK;
677*01826a49SYabin Cui }
678*01826a49SYabin Cui
679*01826a49SYabin Cui
680*01826a49SYabin Cui #if ZLIB_VERNUM >= 0x1240
z_inflateReset2(z_streamp strm,int windowBits)681*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateReset2 _Z_OF((z_streamp strm,
682*01826a49SYabin Cui int windowBits))
683*01826a49SYabin Cui {
684*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
685*01826a49SYabin Cui return inflateReset2(strm, windowBits);
686*01826a49SYabin Cui
687*01826a49SYabin Cui { int const ret = z_inflateReset (strm);
688*01826a49SYabin Cui if (ret == Z_OK) {
689*01826a49SYabin Cui ZWRAP_DCtx* const zwd = (ZWRAP_DCtx*)strm->state;
690*01826a49SYabin Cui if (zwd == NULL) return Z_STREAM_ERROR;
691*01826a49SYabin Cui zwd->windowBits = windowBits;
692*01826a49SYabin Cui }
693*01826a49SYabin Cui return ret;
694*01826a49SYabin Cui }
695*01826a49SYabin Cui }
696*01826a49SYabin Cui #endif
697*01826a49SYabin Cui
698*01826a49SYabin Cui
z_inflateSetDictionary(z_streamp strm,const Bytef * dictionary,uInt dictLength)699*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateSetDictionary _Z_OF((z_streamp strm,
700*01826a49SYabin Cui const Bytef *dictionary,
701*01826a49SYabin Cui uInt dictLength))
702*01826a49SYabin Cui {
703*01826a49SYabin Cui LOG_WRAPPERD("- inflateSetDictionary\n");
704*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
705*01826a49SYabin Cui return inflateSetDictionary(strm, dictionary, dictLength);
706*01826a49SYabin Cui
707*01826a49SYabin Cui { ZWRAP_DCtx* const zwd = (ZWRAP_DCtx*) strm->state;
708*01826a49SYabin Cui if (zwd == NULL || zwd->zbd == NULL) return Z_STREAM_ERROR;
709*01826a49SYabin Cui { size_t const resetErr = ZSTD_DCtx_reset(zwd->zbd, ZSTD_reset_session_only);
710*01826a49SYabin Cui if (ZSTD_isError(resetErr)) return ZWRAPD_finishWithError(zwd, strm, 0); }
711*01826a49SYabin Cui { size_t const loadErr = ZSTD_DCtx_loadDictionary(zwd->zbd, dictionary, dictLength);
712*01826a49SYabin Cui if (ZSTD_isError(loadErr)) return ZWRAPD_finishWithError(zwd, strm, 0); }
713*01826a49SYabin Cui zwd->decompState = ZWRAP_useReset;
714*01826a49SYabin Cui
715*01826a49SYabin Cui if (zwd->totalInBytes == ZSTD_HEADERSIZE) {
716*01826a49SYabin Cui zwd->inBuffer.src = zwd->headerBuf;
717*01826a49SYabin Cui zwd->inBuffer.size = zwd->totalInBytes;
718*01826a49SYabin Cui zwd->inBuffer.pos = 0;
719*01826a49SYabin Cui zwd->outBuffer.dst = strm->next_out;
720*01826a49SYabin Cui zwd->outBuffer.size = 0;
721*01826a49SYabin Cui zwd->outBuffer.pos = 0;
722*01826a49SYabin Cui { size_t const errorCode = ZSTD_decompressStream(zwd->zbd, &zwd->outBuffer, &zwd->inBuffer);
723*01826a49SYabin Cui LOG_WRAPPERD("inflateSetDictionary ZSTD_decompressStream errorCode=%d srcSize=%d dstCapacity=%d\n",
724*01826a49SYabin Cui (int)errorCode, (int)zwd->inBuffer.size, (int)zwd->outBuffer.size);
725*01826a49SYabin Cui if (zwd->inBuffer.pos < zwd->outBuffer.size || ZSTD_isError(errorCode)) {
726*01826a49SYabin Cui LOG_WRAPPERD("ERROR: ZSTD_decompressStream %s\n",
727*01826a49SYabin Cui ZSTD_getErrorName(errorCode));
728*01826a49SYabin Cui return ZWRAPD_finishWithError(zwd, strm, 0);
729*01826a49SYabin Cui } } } }
730*01826a49SYabin Cui
731*01826a49SYabin Cui return Z_OK;
732*01826a49SYabin Cui }
733*01826a49SYabin Cui
734*01826a49SYabin Cui
z_inflate(z_streamp strm,int flush)735*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflate _Z_OF((z_streamp strm, int flush))
736*01826a49SYabin Cui {
737*01826a49SYabin Cui ZWRAP_DCtx* zwd;
738*01826a49SYabin Cui
739*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved) {
740*01826a49SYabin Cui int const result = inflate(strm, flush);
741*01826a49SYabin Cui LOG_WRAPPERD("- inflate2 flush=%d avail_in=%d avail_out=%d total_in=%d total_out=%d res=%d\n",
742*01826a49SYabin Cui (int)flush, (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out, result);
743*01826a49SYabin Cui return result;
744*01826a49SYabin Cui }
745*01826a49SYabin Cui
746*01826a49SYabin Cui if (strm->avail_in <= 0) return Z_OK;
747*01826a49SYabin Cui
748*01826a49SYabin Cui zwd = (ZWRAP_DCtx*) strm->state;
749*01826a49SYabin Cui LOG_WRAPPERD("- inflate1 flush=%d avail_in=%d avail_out=%d total_in=%d total_out=%d\n",
750*01826a49SYabin Cui (int)flush, (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out);
751*01826a49SYabin Cui
752*01826a49SYabin Cui if (zwd == NULL) return Z_STREAM_ERROR;
753*01826a49SYabin Cui if (zwd->decompState == ZWRAP_streamEnd) return Z_STREAM_END;
754*01826a49SYabin Cui
755*01826a49SYabin Cui if (zwd->totalInBytes < ZLIB_HEADERSIZE) {
756*01826a49SYabin Cui if (zwd->totalInBytes == 0 && strm->avail_in >= ZLIB_HEADERSIZE) {
757*01826a49SYabin Cui if (ZWRAP_readLE32(strm->next_in) != ZSTD_MAGICNUMBER) {
758*01826a49SYabin Cui { int const initErr = (zwd->windowBits) ?
759*01826a49SYabin Cui inflateInit2_(strm, zwd->windowBits, zwd->version, zwd->stream_size) :
760*01826a49SYabin Cui inflateInit_(strm, zwd->version, zwd->stream_size);
761*01826a49SYabin Cui LOG_WRAPPERD("ZLIB inflateInit errorCode=%d\n", initErr);
762*01826a49SYabin Cui if (initErr != Z_OK) return ZWRAPD_finishWithError(zwd, strm, initErr);
763*01826a49SYabin Cui }
764*01826a49SYabin Cui
765*01826a49SYabin Cui strm->reserved = ZWRAP_ZLIB_STREAM;
766*01826a49SYabin Cui { size_t const freeErr = ZWRAP_freeDCtx(zwd);
767*01826a49SYabin Cui if (ZSTD_isError(freeErr)) goto error; }
768*01826a49SYabin Cui
769*01826a49SYabin Cui { int const result = (flush == Z_INFLATE_SYNC) ?
770*01826a49SYabin Cui inflateSync(strm) :
771*01826a49SYabin Cui inflate(strm, flush);
772*01826a49SYabin Cui LOG_WRAPPERD("- inflate3 flush=%d avail_in=%d avail_out=%d total_in=%d total_out=%d res=%d\n",
773*01826a49SYabin Cui (int)flush, (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out, res);
774*01826a49SYabin Cui return result;
775*01826a49SYabin Cui } }
776*01826a49SYabin Cui } else { /* ! (zwd->totalInBytes == 0 && strm->avail_in >= ZLIB_HEADERSIZE) */
777*01826a49SYabin Cui size_t const srcSize = MIN(strm->avail_in, ZLIB_HEADERSIZE - zwd->totalInBytes);
778*01826a49SYabin Cui memcpy(zwd->headerBuf+zwd->totalInBytes, strm->next_in, srcSize);
779*01826a49SYabin Cui strm->total_in += srcSize;
780*01826a49SYabin Cui zwd->totalInBytes += srcSize;
781*01826a49SYabin Cui strm->next_in += srcSize;
782*01826a49SYabin Cui strm->avail_in -= srcSize;
783*01826a49SYabin Cui if (zwd->totalInBytes < ZLIB_HEADERSIZE) return Z_OK;
784*01826a49SYabin Cui
785*01826a49SYabin Cui if (ZWRAP_readLE32(zwd->headerBuf) != ZSTD_MAGICNUMBER) {
786*01826a49SYabin Cui z_stream strm2;
787*01826a49SYabin Cui strm2.next_in = strm->next_in;
788*01826a49SYabin Cui strm2.avail_in = strm->avail_in;
789*01826a49SYabin Cui strm2.next_out = strm->next_out;
790*01826a49SYabin Cui strm2.avail_out = strm->avail_out;
791*01826a49SYabin Cui
792*01826a49SYabin Cui { int const initErr = (zwd->windowBits) ?
793*01826a49SYabin Cui inflateInit2_(strm, zwd->windowBits, zwd->version, zwd->stream_size) :
794*01826a49SYabin Cui inflateInit_(strm, zwd->version, zwd->stream_size);
795*01826a49SYabin Cui LOG_WRAPPERD("ZLIB inflateInit errorCode=%d\n", initErr);
796*01826a49SYabin Cui if (initErr != Z_OK) return ZWRAPD_finishWithError(zwd, strm, initErr);
797*01826a49SYabin Cui }
798*01826a49SYabin Cui
799*01826a49SYabin Cui /* inflate header */
800*01826a49SYabin Cui strm->next_in = (unsigned char*)zwd->headerBuf;
801*01826a49SYabin Cui strm->avail_in = ZLIB_HEADERSIZE;
802*01826a49SYabin Cui strm->avail_out = 0;
803*01826a49SYabin Cui { int const dErr = inflate(strm, Z_NO_FLUSH);
804*01826a49SYabin Cui LOG_WRAPPERD("ZLIB inflate errorCode=%d strm->avail_in=%d\n",
805*01826a49SYabin Cui dErr, (int)strm->avail_in);
806*01826a49SYabin Cui if (dErr != Z_OK)
807*01826a49SYabin Cui return ZWRAPD_finishWithError(zwd, strm, dErr);
808*01826a49SYabin Cui }
809*01826a49SYabin Cui if (strm->avail_in > 0) goto error;
810*01826a49SYabin Cui
811*01826a49SYabin Cui strm->next_in = strm2.next_in;
812*01826a49SYabin Cui strm->avail_in = strm2.avail_in;
813*01826a49SYabin Cui strm->next_out = strm2.next_out;
814*01826a49SYabin Cui strm->avail_out = strm2.avail_out;
815*01826a49SYabin Cui
816*01826a49SYabin Cui strm->reserved = ZWRAP_ZLIB_STREAM; /* mark as zlib stream */
817*01826a49SYabin Cui { size_t const freeErr = ZWRAP_freeDCtx(zwd);
818*01826a49SYabin Cui if (ZSTD_isError(freeErr)) goto error; }
819*01826a49SYabin Cui
820*01826a49SYabin Cui { int const result = (flush == Z_INFLATE_SYNC) ?
821*01826a49SYabin Cui inflateSync(strm) :
822*01826a49SYabin Cui inflate(strm, flush);
823*01826a49SYabin Cui LOG_WRAPPERD("- inflate2 flush=%d avail_in=%d avail_out=%d total_in=%d total_out=%d res=%d\n",
824*01826a49SYabin Cui (int)flush, (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out, res);
825*01826a49SYabin Cui return result;
826*01826a49SYabin Cui } } } /* if ! (zwd->totalInBytes == 0 && strm->avail_in >= ZLIB_HEADERSIZE) */
827*01826a49SYabin Cui } /* (zwd->totalInBytes < ZLIB_HEADERSIZE) */
828*01826a49SYabin Cui
829*01826a49SYabin Cui strm->reserved = ZWRAP_ZSTD_STREAM; /* mark as zstd steam */
830*01826a49SYabin Cui
831*01826a49SYabin Cui if (flush == Z_INFLATE_SYNC) { strm->msg = "inflateSync is not supported!"; goto error; }
832*01826a49SYabin Cui
833*01826a49SYabin Cui if (!zwd->zbd) {
834*01826a49SYabin Cui zwd->zbd = ZSTD_createDStream_advanced(zwd->customMem);
835*01826a49SYabin Cui if (zwd->zbd == NULL) { LOG_WRAPPERD("ERROR: ZSTD_createDStream_advanced\n"); goto error; }
836*01826a49SYabin Cui zwd->decompState = ZWRAP_useInit;
837*01826a49SYabin Cui }
838*01826a49SYabin Cui
839*01826a49SYabin Cui if (zwd->totalInBytes < ZSTD_HEADERSIZE) {
840*01826a49SYabin Cui if (zwd->totalInBytes == 0 && strm->avail_in >= ZSTD_HEADERSIZE) {
841*01826a49SYabin Cui if (zwd->decompState == ZWRAP_useInit) {
842*01826a49SYabin Cui size_t const initErr = ZSTD_initDStream(zwd->zbd);
843*01826a49SYabin Cui if (ZSTD_isError(initErr)) {
844*01826a49SYabin Cui LOG_WRAPPERD("ERROR: ZSTD_initDStream errorCode=%s\n",
845*01826a49SYabin Cui ZSTD_getErrorName(initErr));
846*01826a49SYabin Cui goto error;
847*01826a49SYabin Cui }
848*01826a49SYabin Cui } else {
849*01826a49SYabin Cui size_t const resetErr = ZSTD_DCtx_reset(zwd->zbd, ZSTD_reset_session_only);
850*01826a49SYabin Cui if (ZSTD_isError(resetErr)) goto error;
851*01826a49SYabin Cui }
852*01826a49SYabin Cui } else {
853*01826a49SYabin Cui size_t const srcSize = MIN(strm->avail_in, ZSTD_HEADERSIZE - zwd->totalInBytes);
854*01826a49SYabin Cui memcpy(zwd->headerBuf+zwd->totalInBytes, strm->next_in, srcSize);
855*01826a49SYabin Cui strm->total_in += srcSize;
856*01826a49SYabin Cui zwd->totalInBytes += srcSize;
857*01826a49SYabin Cui strm->next_in += srcSize;
858*01826a49SYabin Cui strm->avail_in -= srcSize;
859*01826a49SYabin Cui if (zwd->totalInBytes < ZSTD_HEADERSIZE) return Z_OK;
860*01826a49SYabin Cui
861*01826a49SYabin Cui if (zwd->decompState == ZWRAP_useInit) {
862*01826a49SYabin Cui size_t const initErr = ZSTD_initDStream(zwd->zbd);
863*01826a49SYabin Cui if (ZSTD_isError(initErr)) {
864*01826a49SYabin Cui LOG_WRAPPERD("ERROR: ZSTD_initDStream errorCode=%s\n",
865*01826a49SYabin Cui ZSTD_getErrorName(initErr));
866*01826a49SYabin Cui goto error;
867*01826a49SYabin Cui }
868*01826a49SYabin Cui } else {
869*01826a49SYabin Cui size_t const resetErr = ZSTD_DCtx_reset(zwd->zbd, ZSTD_reset_session_only);
870*01826a49SYabin Cui if (ZSTD_isError(resetErr)) goto error;
871*01826a49SYabin Cui }
872*01826a49SYabin Cui
873*01826a49SYabin Cui zwd->inBuffer.src = zwd->headerBuf;
874*01826a49SYabin Cui zwd->inBuffer.size = ZSTD_HEADERSIZE;
875*01826a49SYabin Cui zwd->inBuffer.pos = 0;
876*01826a49SYabin Cui zwd->outBuffer.dst = strm->next_out;
877*01826a49SYabin Cui zwd->outBuffer.size = 0;
878*01826a49SYabin Cui zwd->outBuffer.pos = 0;
879*01826a49SYabin Cui { size_t const dErr = ZSTD_decompressStream(zwd->zbd, &zwd->outBuffer, &zwd->inBuffer);
880*01826a49SYabin Cui LOG_WRAPPERD("inflate ZSTD_decompressStream1 errorCode=%d srcSize=%d dstCapacity=%d\n",
881*01826a49SYabin Cui (int)dErr, (int)zwd->inBuffer.size, (int)zwd->outBuffer.size);
882*01826a49SYabin Cui if (ZSTD_isError(dErr)) {
883*01826a49SYabin Cui LOG_WRAPPERD("ERROR: ZSTD_decompressStream1 %s\n", ZSTD_getErrorName(dErr));
884*01826a49SYabin Cui goto error;
885*01826a49SYabin Cui } }
886*01826a49SYabin Cui if (zwd->inBuffer.pos != zwd->inBuffer.size) goto error; /* not consumed */
887*01826a49SYabin Cui }
888*01826a49SYabin Cui } /* (zwd->totalInBytes < ZSTD_HEADERSIZE) */
889*01826a49SYabin Cui
890*01826a49SYabin Cui zwd->inBuffer.src = strm->next_in;
891*01826a49SYabin Cui zwd->inBuffer.size = strm->avail_in;
892*01826a49SYabin Cui zwd->inBuffer.pos = 0;
893*01826a49SYabin Cui zwd->outBuffer.dst = strm->next_out;
894*01826a49SYabin Cui zwd->outBuffer.size = strm->avail_out;
895*01826a49SYabin Cui zwd->outBuffer.pos = 0;
896*01826a49SYabin Cui { size_t const dErr = ZSTD_decompressStream(zwd->zbd, &zwd->outBuffer, &zwd->inBuffer);
897*01826a49SYabin Cui LOG_WRAPPERD("inflate ZSTD_decompressStream2 errorCode=%d srcSize=%d dstCapacity=%d\n",
898*01826a49SYabin Cui (int)dErr, (int)strm->avail_in, (int)strm->avail_out);
899*01826a49SYabin Cui if (ZSTD_isError(dErr)) {
900*01826a49SYabin Cui zwd->errorCount++;
901*01826a49SYabin Cui LOG_WRAPPERD("ERROR: ZSTD_decompressStream2 %s zwd->errorCount=%d\n",
902*01826a49SYabin Cui ZSTD_getErrorName(dErr), zwd->errorCount);
903*01826a49SYabin Cui if (zwd->errorCount<=1) return Z_NEED_DICT; else goto error;
904*01826a49SYabin Cui }
905*01826a49SYabin Cui LOG_WRAPPERD("inflate inBuffer.pos=%d inBuffer.size=%d outBuffer.pos=%d outBuffer.size=%d o\n",
906*01826a49SYabin Cui (int)zwd->inBuffer.pos, (int)zwd->inBuffer.size, (int)zwd->outBuffer.pos, (int)zwd->outBuffer.size);
907*01826a49SYabin Cui strm->next_out += zwd->outBuffer.pos;
908*01826a49SYabin Cui strm->total_out += zwd->outBuffer.pos;
909*01826a49SYabin Cui strm->avail_out -= zwd->outBuffer.pos;
910*01826a49SYabin Cui strm->total_in += zwd->inBuffer.pos;
911*01826a49SYabin Cui zwd->totalInBytes += zwd->inBuffer.pos;
912*01826a49SYabin Cui strm->next_in += zwd->inBuffer.pos;
913*01826a49SYabin Cui strm->avail_in -= zwd->inBuffer.pos;
914*01826a49SYabin Cui if (dErr == 0) {
915*01826a49SYabin Cui LOG_WRAPPERD("inflate Z_STREAM_END1 avail_in=%d avail_out=%d total_in=%d total_out=%d\n",
916*01826a49SYabin Cui (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out);
917*01826a49SYabin Cui zwd->decompState = ZWRAP_streamEnd;
918*01826a49SYabin Cui return Z_STREAM_END;
919*01826a49SYabin Cui }
920*01826a49SYabin Cui } /* dErr lifetime */
921*01826a49SYabin Cui
922*01826a49SYabin Cui LOG_WRAPPERD("- inflate2 flush=%d avail_in=%d avail_out=%d total_in=%d total_out=%d res=%d\n",
923*01826a49SYabin Cui (int)flush, (int)strm->avail_in, (int)strm->avail_out, (int)strm->total_in, (int)strm->total_out, Z_OK);
924*01826a49SYabin Cui return Z_OK;
925*01826a49SYabin Cui
926*01826a49SYabin Cui error:
927*01826a49SYabin Cui return ZWRAPD_finishWithError(zwd, strm, 0);
928*01826a49SYabin Cui }
929*01826a49SYabin Cui
930*01826a49SYabin Cui
z_inflateEnd(z_streamp strm)931*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateEnd _Z_OF((z_streamp strm))
932*01826a49SYabin Cui {
933*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
934*01826a49SYabin Cui return inflateEnd(strm);
935*01826a49SYabin Cui
936*01826a49SYabin Cui LOG_WRAPPERD("- inflateEnd total_in=%d total_out=%d\n",
937*01826a49SYabin Cui (int)(strm->total_in), (int)(strm->total_out));
938*01826a49SYabin Cui { ZWRAP_DCtx* const zwd = (ZWRAP_DCtx*) strm->state;
939*01826a49SYabin Cui if (zwd == NULL) return Z_OK; /* structures are already freed */
940*01826a49SYabin Cui { size_t const freeErr = ZWRAP_freeDCtx(zwd);
941*01826a49SYabin Cui if (ZSTD_isError(freeErr)) return Z_STREAM_ERROR; }
942*01826a49SYabin Cui strm->state = NULL;
943*01826a49SYabin Cui }
944*01826a49SYabin Cui return Z_OK;
945*01826a49SYabin Cui }
946*01826a49SYabin Cui
947*01826a49SYabin Cui
z_inflateSync(z_streamp strm)948*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateSync _Z_OF((z_streamp strm))
949*01826a49SYabin Cui {
950*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved) {
951*01826a49SYabin Cui return inflateSync(strm);
952*01826a49SYabin Cui }
953*01826a49SYabin Cui
954*01826a49SYabin Cui return z_inflate(strm, Z_INFLATE_SYNC);
955*01826a49SYabin Cui }
956*01826a49SYabin Cui
957*01826a49SYabin Cui
958*01826a49SYabin Cui
959*01826a49SYabin Cui /* Advanced compression functions */
z_deflateCopy(z_streamp dest,z_streamp source)960*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateCopy _Z_OF((z_streamp dest,
961*01826a49SYabin Cui z_streamp source))
962*01826a49SYabin Cui {
963*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
964*01826a49SYabin Cui return deflateCopy(dest, source);
965*01826a49SYabin Cui return ZWRAPC_finishWithErrorMsg(source, "deflateCopy is not supported!");
966*01826a49SYabin Cui }
967*01826a49SYabin Cui
968*01826a49SYabin Cui
z_deflateTune(z_streamp strm,int good_length,int max_lazy,int nice_length,int max_chain)969*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateTune _Z_OF((z_streamp strm,
970*01826a49SYabin Cui int good_length,
971*01826a49SYabin Cui int max_lazy,
972*01826a49SYabin Cui int nice_length,
973*01826a49SYabin Cui int max_chain))
974*01826a49SYabin Cui {
975*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
976*01826a49SYabin Cui return deflateTune(strm, good_length, max_lazy, nice_length, max_chain);
977*01826a49SYabin Cui return ZWRAPC_finishWithErrorMsg(strm, "deflateTune is not supported!");
978*01826a49SYabin Cui }
979*01826a49SYabin Cui
980*01826a49SYabin Cui
981*01826a49SYabin Cui #if ZLIB_VERNUM >= 0x1260
z_deflatePending(z_streamp strm,unsigned * pending,int * bits)982*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflatePending _Z_OF((z_streamp strm,
983*01826a49SYabin Cui unsigned *pending,
984*01826a49SYabin Cui int *bits))
985*01826a49SYabin Cui {
986*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
987*01826a49SYabin Cui return deflatePending(strm, pending, bits);
988*01826a49SYabin Cui return ZWRAPC_finishWithErrorMsg(strm, "deflatePending is not supported!");
989*01826a49SYabin Cui }
990*01826a49SYabin Cui #endif
991*01826a49SYabin Cui
992*01826a49SYabin Cui
z_deflatePrime(z_streamp strm,int bits,int value)993*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflatePrime _Z_OF((z_streamp strm,
994*01826a49SYabin Cui int bits,
995*01826a49SYabin Cui int value))
996*01826a49SYabin Cui {
997*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
998*01826a49SYabin Cui return deflatePrime(strm, bits, value);
999*01826a49SYabin Cui return ZWRAPC_finishWithErrorMsg(strm, "deflatePrime is not supported!");
1000*01826a49SYabin Cui }
1001*01826a49SYabin Cui
1002*01826a49SYabin Cui
z_deflateSetHeader(z_streamp strm,gz_headerp head)1003*01826a49SYabin Cui ZEXTERN int ZEXPORT z_deflateSetHeader _Z_OF((z_streamp strm,
1004*01826a49SYabin Cui gz_headerp head))
1005*01826a49SYabin Cui {
1006*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
1007*01826a49SYabin Cui return deflateSetHeader(strm, head);
1008*01826a49SYabin Cui return ZWRAPC_finishWithErrorMsg(strm, "deflateSetHeader is not supported!");
1009*01826a49SYabin Cui }
1010*01826a49SYabin Cui
1011*01826a49SYabin Cui
1012*01826a49SYabin Cui
1013*01826a49SYabin Cui
1014*01826a49SYabin Cui /* Advanced decompression functions */
1015*01826a49SYabin Cui #if ZLIB_VERNUM >= 0x1280
z_inflateGetDictionary(z_streamp strm,Bytef * dictionary,uInt * dictLength)1016*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateGetDictionary _Z_OF((z_streamp strm,
1017*01826a49SYabin Cui Bytef *dictionary,
1018*01826a49SYabin Cui uInt *dictLength))
1019*01826a49SYabin Cui {
1020*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
1021*01826a49SYabin Cui return inflateGetDictionary(strm, dictionary, dictLength);
1022*01826a49SYabin Cui return ZWRAPD_finishWithErrorMsg(strm, "inflateGetDictionary is not supported!");
1023*01826a49SYabin Cui }
1024*01826a49SYabin Cui #endif
1025*01826a49SYabin Cui
1026*01826a49SYabin Cui
z_inflateCopy(z_streamp dest,z_streamp source)1027*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateCopy _Z_OF((z_streamp dest,
1028*01826a49SYabin Cui z_streamp source))
1029*01826a49SYabin Cui {
1030*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !source->reserved)
1031*01826a49SYabin Cui return inflateCopy(dest, source);
1032*01826a49SYabin Cui return ZWRAPD_finishWithErrorMsg(source, "inflateCopy is not supported!");
1033*01826a49SYabin Cui }
1034*01826a49SYabin Cui
1035*01826a49SYabin Cui
1036*01826a49SYabin Cui #if ZLIB_VERNUM >= 0x1240
z_inflateMark(z_streamp strm)1037*01826a49SYabin Cui ZEXTERN long ZEXPORT z_inflateMark _Z_OF((z_streamp strm))
1038*01826a49SYabin Cui {
1039*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
1040*01826a49SYabin Cui return inflateMark(strm);
1041*01826a49SYabin Cui return ZWRAPD_finishWithErrorMsg(strm, "inflateMark is not supported!");
1042*01826a49SYabin Cui }
1043*01826a49SYabin Cui #endif
1044*01826a49SYabin Cui
1045*01826a49SYabin Cui
z_inflatePrime(z_streamp strm,int bits,int value)1046*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflatePrime _Z_OF((z_streamp strm,
1047*01826a49SYabin Cui int bits,
1048*01826a49SYabin Cui int value))
1049*01826a49SYabin Cui {
1050*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
1051*01826a49SYabin Cui return inflatePrime(strm, bits, value);
1052*01826a49SYabin Cui return ZWRAPD_finishWithErrorMsg(strm, "inflatePrime is not supported!");
1053*01826a49SYabin Cui }
1054*01826a49SYabin Cui
1055*01826a49SYabin Cui
z_inflateGetHeader(z_streamp strm,gz_headerp head)1056*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateGetHeader _Z_OF((z_streamp strm,
1057*01826a49SYabin Cui gz_headerp head))
1058*01826a49SYabin Cui {
1059*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
1060*01826a49SYabin Cui return inflateGetHeader(strm, head);
1061*01826a49SYabin Cui return ZWRAPD_finishWithErrorMsg(strm, "inflateGetHeader is not supported!");
1062*01826a49SYabin Cui }
1063*01826a49SYabin Cui
1064*01826a49SYabin Cui
z_inflateBackInit_(z_streamp strm,int windowBits,unsigned char FAR * window,const char * version,int stream_size)1065*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateBackInit_ _Z_OF((z_streamp strm, int windowBits,
1066*01826a49SYabin Cui unsigned char FAR *window,
1067*01826a49SYabin Cui const char *version,
1068*01826a49SYabin Cui int stream_size))
1069*01826a49SYabin Cui {
1070*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
1071*01826a49SYabin Cui return inflateBackInit_(strm, windowBits, window, version, stream_size);
1072*01826a49SYabin Cui return ZWRAPD_finishWithErrorMsg(strm, "inflateBackInit is not supported!");
1073*01826a49SYabin Cui }
1074*01826a49SYabin Cui
1075*01826a49SYabin Cui
z_inflateBack(z_streamp strm,in_func in,void FAR * in_desc,out_func out,void FAR * out_desc)1076*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateBack _Z_OF((z_streamp strm,
1077*01826a49SYabin Cui in_func in, void FAR *in_desc,
1078*01826a49SYabin Cui out_func out, void FAR *out_desc))
1079*01826a49SYabin Cui {
1080*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
1081*01826a49SYabin Cui return inflateBack(strm, in, in_desc, out, out_desc);
1082*01826a49SYabin Cui return ZWRAPD_finishWithErrorMsg(strm, "inflateBack is not supported!");
1083*01826a49SYabin Cui }
1084*01826a49SYabin Cui
1085*01826a49SYabin Cui
z_inflateBackEnd(z_streamp strm)1086*01826a49SYabin Cui ZEXTERN int ZEXPORT z_inflateBackEnd _Z_OF((z_streamp strm))
1087*01826a49SYabin Cui {
1088*01826a49SYabin Cui if (g_ZWRAPdecompressionType == ZWRAP_FORCE_ZLIB || !strm->reserved)
1089*01826a49SYabin Cui return inflateBackEnd(strm);
1090*01826a49SYabin Cui return ZWRAPD_finishWithErrorMsg(strm, "inflateBackEnd is not supported!");
1091*01826a49SYabin Cui }
1092*01826a49SYabin Cui
1093*01826a49SYabin Cui
z_zlibCompileFlags(void)1094*01826a49SYabin Cui ZEXTERN uLong ZEXPORT z_zlibCompileFlags _Z_OF((void)) { return zlibCompileFlags(); }
1095*01826a49SYabin Cui
1096*01826a49SYabin Cui
1097*01826a49SYabin Cui
1098*01826a49SYabin Cui /* === utility functions === */
1099*01826a49SYabin Cui #ifndef Z_SOLO
1100*01826a49SYabin Cui
z_compress(Bytef * dest,uLongf * destLen,const Bytef * source,uLong sourceLen)1101*01826a49SYabin Cui ZEXTERN int ZEXPORT z_compress _Z_OF((Bytef *dest, uLongf *destLen,
1102*01826a49SYabin Cui const Bytef *source, uLong sourceLen))
1103*01826a49SYabin Cui {
1104*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
1105*01826a49SYabin Cui return compress(dest, destLen, source, sourceLen);
1106*01826a49SYabin Cui
1107*01826a49SYabin Cui { size_t dstCapacity = *destLen;
1108*01826a49SYabin Cui size_t const cSize = ZSTD_compress(dest, dstCapacity,
1109*01826a49SYabin Cui source, sourceLen,
1110*01826a49SYabin Cui ZWRAP_DEFAULT_CLEVEL);
1111*01826a49SYabin Cui LOG_WRAPPERD("z_compress sourceLen=%d dstCapacity=%d\n",
1112*01826a49SYabin Cui (int)sourceLen, (int)dstCapacity);
1113*01826a49SYabin Cui if (ZSTD_isError(cSize)) return Z_STREAM_ERROR;
1114*01826a49SYabin Cui *destLen = cSize;
1115*01826a49SYabin Cui }
1116*01826a49SYabin Cui return Z_OK;
1117*01826a49SYabin Cui }
1118*01826a49SYabin Cui
1119*01826a49SYabin Cui
z_compress2(Bytef * dest,uLongf * destLen,const Bytef * source,uLong sourceLen,int level)1120*01826a49SYabin Cui ZEXTERN int ZEXPORT z_compress2 _Z_OF((Bytef *dest, uLongf *destLen,
1121*01826a49SYabin Cui const Bytef *source, uLong sourceLen,
1122*01826a49SYabin Cui int level))
1123*01826a49SYabin Cui {
1124*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
1125*01826a49SYabin Cui return compress2(dest, destLen, source, sourceLen, level);
1126*01826a49SYabin Cui
1127*01826a49SYabin Cui { size_t dstCapacity = *destLen;
1128*01826a49SYabin Cui size_t const cSize = ZSTD_compress(dest, dstCapacity, source, sourceLen, level);
1129*01826a49SYabin Cui if (ZSTD_isError(cSize)) return Z_STREAM_ERROR;
1130*01826a49SYabin Cui *destLen = cSize;
1131*01826a49SYabin Cui }
1132*01826a49SYabin Cui return Z_OK;
1133*01826a49SYabin Cui }
1134*01826a49SYabin Cui
1135*01826a49SYabin Cui
z_compressBound(uLong sourceLen)1136*01826a49SYabin Cui ZEXTERN uLong ZEXPORT z_compressBound _Z_OF((uLong sourceLen))
1137*01826a49SYabin Cui {
1138*01826a49SYabin Cui if (!g_ZWRAP_useZSTDcompression)
1139*01826a49SYabin Cui return compressBound(sourceLen);
1140*01826a49SYabin Cui
1141*01826a49SYabin Cui return ZSTD_compressBound(sourceLen);
1142*01826a49SYabin Cui }
1143*01826a49SYabin Cui
1144*01826a49SYabin Cui
z_uncompress(Bytef * dest,uLongf * destLen,const Bytef * source,uLong sourceLen)1145*01826a49SYabin Cui ZEXTERN int ZEXPORT z_uncompress _Z_OF((Bytef *dest, uLongf *destLen,
1146*01826a49SYabin Cui const Bytef *source, uLong sourceLen))
1147*01826a49SYabin Cui {
1148*01826a49SYabin Cui if (!ZSTD_isFrame(source, sourceLen))
1149*01826a49SYabin Cui return uncompress(dest, destLen, source, sourceLen);
1150*01826a49SYabin Cui
1151*01826a49SYabin Cui { size_t dstCapacity = *destLen;
1152*01826a49SYabin Cui size_t const dSize = ZSTD_decompress(dest, dstCapacity, source, sourceLen);
1153*01826a49SYabin Cui if (ZSTD_isError(dSize)) return Z_STREAM_ERROR;
1154*01826a49SYabin Cui *destLen = dSize;
1155*01826a49SYabin Cui }
1156*01826a49SYabin Cui return Z_OK;
1157*01826a49SYabin Cui }
1158*01826a49SYabin Cui
1159*01826a49SYabin Cui #endif /* !Z_SOLO */
1160*01826a49SYabin Cui
1161*01826a49SYabin Cui
1162*01826a49SYabin Cui /* checksum functions */
1163*01826a49SYabin Cui
z_adler32(uLong adler,const Bytef * buf,uInt len)1164*01826a49SYabin Cui ZEXTERN uLong ZEXPORT z_adler32 _Z_OF((uLong adler, const Bytef *buf, uInt len))
1165*01826a49SYabin Cui {
1166*01826a49SYabin Cui return adler32(adler, buf, len);
1167*01826a49SYabin Cui }
1168*01826a49SYabin Cui
z_crc32(uLong crc,const Bytef * buf,uInt len)1169*01826a49SYabin Cui ZEXTERN uLong ZEXPORT z_crc32 _Z_OF((uLong crc, const Bytef *buf, uInt len))
1170*01826a49SYabin Cui {
1171*01826a49SYabin Cui return crc32(crc, buf, len);
1172*01826a49SYabin Cui }
1173*01826a49SYabin Cui
1174*01826a49SYabin Cui
1175*01826a49SYabin Cui #if ZLIB_VERNUM >= 0x12B0
z_adler32_z(uLong adler,const Bytef * buf,z_size_t len)1176*01826a49SYabin Cui ZEXTERN uLong ZEXPORT z_adler32_z _Z_OF((uLong adler, const Bytef *buf, z_size_t len))
1177*01826a49SYabin Cui {
1178*01826a49SYabin Cui return adler32_z(adler, buf, len);
1179*01826a49SYabin Cui }
1180*01826a49SYabin Cui
z_crc32_z(uLong crc,const Bytef * buf,z_size_t len)1181*01826a49SYabin Cui ZEXTERN uLong ZEXPORT z_crc32_z _Z_OF((uLong crc, const Bytef *buf, z_size_t len))
1182*01826a49SYabin Cui {
1183*01826a49SYabin Cui return crc32_z(crc, buf, len);
1184*01826a49SYabin Cui }
1185*01826a49SYabin Cui #endif
1186*01826a49SYabin Cui
1187*01826a49SYabin Cui
1188*01826a49SYabin Cui #if ZLIB_VERNUM >= 0x1270
z_get_crc_table(void)1189*01826a49SYabin Cui ZEXTERN const z_crc_t FAR * ZEXPORT z_get_crc_table _Z_OF((void))
1190*01826a49SYabin Cui {
1191*01826a49SYabin Cui return get_crc_table();
1192*01826a49SYabin Cui }
1193*01826a49SYabin Cui #endif
1194*01826a49SYabin Cui
1195*01826a49SYabin Cui /* Error function */
z_zError(int err)1196*01826a49SYabin Cui ZEXTERN const char * ZEXPORT z_zError _Z_OF((int err))
1197*01826a49SYabin Cui {
1198*01826a49SYabin Cui /* Just use zlib Error function */
1199*01826a49SYabin Cui return zError(err);
1200*01826a49SYabin Cui }
1201