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