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   === */
47static int g_ZWRAP_useZSTDcompression = ZWRAP_USE_ZSTD; /* 0 = don't use ZSTD */
48
49void ZWRAP_useZSTDcompression(int turn_on) { g_ZWRAP_useZSTDcompression = turn_on; }
50
51int ZWRAP_isUsingZSTDcompression(void) { return g_ZWRAP_useZSTDcompression; }
52
53
54
55static ZWRAP_decompress_type g_ZWRAPdecompressionType = ZWRAP_AUTO;
56
57void ZWRAP_setDecompressionType(ZWRAP_decompress_type type) { g_ZWRAPdecompressionType = type; };
58
59ZWRAP_decompress_type ZWRAP_getDecompressionType(void) { return g_ZWRAPdecompressionType; }
60
61
62
63const char * zstdVersion(void) { return ZSTD_VERSION_STRING; }
64
65ZEXTERN const char * ZEXPORT z_zlibVersion OF((void)) { return zlibVersion();  }
66
67
68
69static 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
77static 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   === */
87typedef enum { ZWRAP_useInit, ZWRAP_useReset, ZWRAP_streamEnd } ZWRAP_state_t;
88
89typedef 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
102typedef ZWRAP_CCtx internal_state;
103
104
105
106static 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
115static 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
135static 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 searchLength=%d strategy=%d\n",
144                    (int)pledgedSrcSize, params.cParams.windowLog, params.cParams.chainLog, params.cParams.hashLog, params.cParams.searchLog, params.cParams.searchLength, 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
153static 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
162static 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
172int 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
183ZEXTERN 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
210ZEXTERN 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
222int 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
242ZEXTERN 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
257ZEXTERN 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
282ZEXTERN 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
382ZEXTERN 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
400ZEXTERN 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
410ZEXTERN 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
428typedef enum { ZWRAP_ZLIB_STREAM, ZWRAP_ZSTD_STREAM, ZWRAP_UNKNOWN_STREAM } ZWRAP_stream_type;
429
430typedef 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
448static void ZWRAP_initDCtx(ZWRAP_DCtx* zwd)
449{
450    zwd->errorCount = 0;
451    zwd->outBuffer.pos = 0;
452    zwd->outBuffer.size = 0;
453}
454
455static 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
476static 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
486int ZWRAP_isUsingZSTDdecompression(z_streamp strm)
487{
488    if (strm == NULL) return 0;
489    return (strm->reserved == ZWRAP_ZSTD_STREAM);
490}
491
492
493static 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
501static 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
511ZEXTERN 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
540ZEXTERN 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
558int 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
577ZEXTERN 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
595ZEXTERN 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
613ZEXTERN 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
647ZEXTERN 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
838error:
839    return ZWRAPD_finishWithError(zwd, strm, 0);
840}
841
842
843ZEXTERN 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
860ZEXTERN 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 */
872ZEXTERN 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
881ZEXTERN 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
894ZEXTERN 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
905ZEXTERN 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
915ZEXTERN 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
928ZEXTERN 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
939ZEXTERN 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
949ZEXTERN 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
958ZEXTERN 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
968ZEXTERN 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
977ZEXTERN 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
988ZEXTERN 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
998ZEXTERN 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
1006ZEXTERN uLong ZEXPORT z_zlibCompileFlags OF((void)) { return zlibCompileFlags(); };
1007
1008
1009
1010                    /* ===   utility functions  === */
1011#ifndef Z_SOLO
1012
1013ZEXTERN 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
1032ZEXTERN 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
1048ZEXTERN 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
1057ZEXTERN 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
1076ZEXTERN uLong ZEXPORT z_adler32 OF((uLong adler, const Bytef *buf, uInt len))
1077{
1078    return adler32(adler, buf, len);
1079}
1080
1081ZEXTERN 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
1088ZEXTERN 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
1093ZEXTERN 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
1101ZEXTERN const z_crc_t FAR * ZEXPORT z_get_crc_table    OF((void))
1102{
1103    return get_crc_table();
1104}
1105#endif
1106