11e9a6b47SJoerg Sonnenberger /* zutil.c -- target dependent utility functions for the compression library
2*e041647aSSascha Wildner * Copyright (C) 1995-2017 Jean-loup Gailly
31e9a6b47SJoerg Sonnenberger * For conditions of distribution and use, see copyright notice in zlib.h
41e9a6b47SJoerg Sonnenberger */
51e9a6b47SJoerg Sonnenberger
61e9a6b47SJoerg Sonnenberger /* @(#) $Id$ */
71e9a6b47SJoerg Sonnenberger
81e9a6b47SJoerg Sonnenberger #include "zutil.h"
9712f98b7SJohn Marino #ifndef Z_SOLO
10712f98b7SJohn Marino # include "gzguts.h"
11712f98b7SJohn Marino #endif
121e9a6b47SJoerg Sonnenberger
1353ddf67cSJohn Marino z_const char * const z_errmsg[10] = {
14*e041647aSSascha Wildner (z_const char *)"need dictionary", /* Z_NEED_DICT 2 */
15*e041647aSSascha Wildner (z_const char *)"stream end", /* Z_STREAM_END 1 */
16*e041647aSSascha Wildner (z_const char *)"", /* Z_OK 0 */
17*e041647aSSascha Wildner (z_const char *)"file error", /* Z_ERRNO (-1) */
18*e041647aSSascha Wildner (z_const char *)"stream error", /* Z_STREAM_ERROR (-2) */
19*e041647aSSascha Wildner (z_const char *)"data error", /* Z_DATA_ERROR (-3) */
20*e041647aSSascha Wildner (z_const char *)"insufficient memory", /* Z_MEM_ERROR (-4) */
21*e041647aSSascha Wildner (z_const char *)"buffer error", /* Z_BUF_ERROR (-5) */
22*e041647aSSascha Wildner (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
23*e041647aSSascha Wildner (z_const char *)""
24*e041647aSSascha Wildner };
251e9a6b47SJoerg Sonnenberger
261e9a6b47SJoerg Sonnenberger
zlibVersion()271e9a6b47SJoerg Sonnenberger const char * ZEXPORT zlibVersion()
281e9a6b47SJoerg Sonnenberger {
291e9a6b47SJoerg Sonnenberger return ZLIB_VERSION;
301e9a6b47SJoerg Sonnenberger }
311e9a6b47SJoerg Sonnenberger
zlibCompileFlags()321e9a6b47SJoerg Sonnenberger uLong ZEXPORT zlibCompileFlags()
331e9a6b47SJoerg Sonnenberger {
341e9a6b47SJoerg Sonnenberger uLong flags;
351e9a6b47SJoerg Sonnenberger
361e9a6b47SJoerg Sonnenberger flags = 0;
37fe927c51SPeter Avalos switch ((int)(sizeof(uInt))) {
381e9a6b47SJoerg Sonnenberger case 2: break;
391e9a6b47SJoerg Sonnenberger case 4: flags += 1; break;
401e9a6b47SJoerg Sonnenberger case 8: flags += 2; break;
411e9a6b47SJoerg Sonnenberger default: flags += 3;
421e9a6b47SJoerg Sonnenberger }
43fe927c51SPeter Avalos switch ((int)(sizeof(uLong))) {
441e9a6b47SJoerg Sonnenberger case 2: break;
451e9a6b47SJoerg Sonnenberger case 4: flags += 1 << 2; break;
461e9a6b47SJoerg Sonnenberger case 8: flags += 2 << 2; break;
471e9a6b47SJoerg Sonnenberger default: flags += 3 << 2;
481e9a6b47SJoerg Sonnenberger }
49fe927c51SPeter Avalos switch ((int)(sizeof(voidpf))) {
501e9a6b47SJoerg Sonnenberger case 2: break;
511e9a6b47SJoerg Sonnenberger case 4: flags += 1 << 4; break;
521e9a6b47SJoerg Sonnenberger case 8: flags += 2 << 4; break;
531e9a6b47SJoerg Sonnenberger default: flags += 3 << 4;
541e9a6b47SJoerg Sonnenberger }
55fe927c51SPeter Avalos switch ((int)(sizeof(z_off_t))) {
561e9a6b47SJoerg Sonnenberger case 2: break;
571e9a6b47SJoerg Sonnenberger case 4: flags += 1 << 6; break;
581e9a6b47SJoerg Sonnenberger case 8: flags += 2 << 6; break;
591e9a6b47SJoerg Sonnenberger default: flags += 3 << 6;
601e9a6b47SJoerg Sonnenberger }
61*e041647aSSascha Wildner #ifdef ZLIB_DEBUG
621e9a6b47SJoerg Sonnenberger flags += 1 << 8;
631e9a6b47SJoerg Sonnenberger #endif
641e9a6b47SJoerg Sonnenberger #if defined(ASMV) || defined(ASMINF)
651e9a6b47SJoerg Sonnenberger flags += 1 << 9;
661e9a6b47SJoerg Sonnenberger #endif
671e9a6b47SJoerg Sonnenberger #ifdef ZLIB_WINAPI
681e9a6b47SJoerg Sonnenberger flags += 1 << 10;
691e9a6b47SJoerg Sonnenberger #endif
701e9a6b47SJoerg Sonnenberger #ifdef BUILDFIXED
711e9a6b47SJoerg Sonnenberger flags += 1 << 12;
721e9a6b47SJoerg Sonnenberger #endif
731e9a6b47SJoerg Sonnenberger #ifdef DYNAMIC_CRC_TABLE
741e9a6b47SJoerg Sonnenberger flags += 1 << 13;
751e9a6b47SJoerg Sonnenberger #endif
761e9a6b47SJoerg Sonnenberger #ifdef NO_GZCOMPRESS
771e9a6b47SJoerg Sonnenberger flags += 1L << 16;
781e9a6b47SJoerg Sonnenberger #endif
791e9a6b47SJoerg Sonnenberger #ifdef NO_GZIP
801e9a6b47SJoerg Sonnenberger flags += 1L << 17;
811e9a6b47SJoerg Sonnenberger #endif
821e9a6b47SJoerg Sonnenberger #ifdef PKZIP_BUG_WORKAROUND
831e9a6b47SJoerg Sonnenberger flags += 1L << 20;
841e9a6b47SJoerg Sonnenberger #endif
851e9a6b47SJoerg Sonnenberger #ifdef FASTEST
861e9a6b47SJoerg Sonnenberger flags += 1L << 21;
871e9a6b47SJoerg Sonnenberger #endif
88712f98b7SJohn Marino #if defined(STDC) || defined(Z_HAVE_STDARG_H)
891e9a6b47SJoerg Sonnenberger # ifdef NO_vsnprintf
901e9a6b47SJoerg Sonnenberger flags += 1L << 25;
911e9a6b47SJoerg Sonnenberger # ifdef HAS_vsprintf_void
921e9a6b47SJoerg Sonnenberger flags += 1L << 26;
931e9a6b47SJoerg Sonnenberger # endif
941e9a6b47SJoerg Sonnenberger # else
951e9a6b47SJoerg Sonnenberger # ifdef HAS_vsnprintf_void
961e9a6b47SJoerg Sonnenberger flags += 1L << 26;
971e9a6b47SJoerg Sonnenberger # endif
981e9a6b47SJoerg Sonnenberger # endif
991e9a6b47SJoerg Sonnenberger #else
1001e9a6b47SJoerg Sonnenberger flags += 1L << 24;
1011e9a6b47SJoerg Sonnenberger # ifdef NO_snprintf
1021e9a6b47SJoerg Sonnenberger flags += 1L << 25;
1031e9a6b47SJoerg Sonnenberger # ifdef HAS_sprintf_void
1041e9a6b47SJoerg Sonnenberger flags += 1L << 26;
1051e9a6b47SJoerg Sonnenberger # endif
1061e9a6b47SJoerg Sonnenberger # else
1071e9a6b47SJoerg Sonnenberger # ifdef HAS_snprintf_void
1081e9a6b47SJoerg Sonnenberger flags += 1L << 26;
1091e9a6b47SJoerg Sonnenberger # endif
1101e9a6b47SJoerg Sonnenberger # endif
1111e9a6b47SJoerg Sonnenberger #endif
1121e9a6b47SJoerg Sonnenberger return flags;
1131e9a6b47SJoerg Sonnenberger }
1141e9a6b47SJoerg Sonnenberger
115*e041647aSSascha Wildner #ifdef ZLIB_DEBUG
116*e041647aSSascha Wildner #include <stdlib.h>
1171e9a6b47SJoerg Sonnenberger # ifndef verbose
1181e9a6b47SJoerg Sonnenberger # define verbose 0
1191e9a6b47SJoerg Sonnenberger # endif
120fe927c51SPeter Avalos int ZLIB_INTERNAL z_verbose = verbose;
1211e9a6b47SJoerg Sonnenberger
z_error(m)122fe927c51SPeter Avalos void ZLIB_INTERNAL z_error (m)
1231e9a6b47SJoerg Sonnenberger char *m;
1241e9a6b47SJoerg Sonnenberger {
1251e9a6b47SJoerg Sonnenberger fprintf(stderr, "%s\n", m);
1261e9a6b47SJoerg Sonnenberger exit(1);
1271e9a6b47SJoerg Sonnenberger }
1281e9a6b47SJoerg Sonnenberger #endif
1291e9a6b47SJoerg Sonnenberger
1301e9a6b47SJoerg Sonnenberger /* exported to allow conversion of error code to string for compress() and
1311e9a6b47SJoerg Sonnenberger * uncompress()
1321e9a6b47SJoerg Sonnenberger */
zError(err)1331e9a6b47SJoerg Sonnenberger const char * ZEXPORT zError(err)
1341e9a6b47SJoerg Sonnenberger int err;
1351e9a6b47SJoerg Sonnenberger {
1361e9a6b47SJoerg Sonnenberger return ERR_MSG(err);
1371e9a6b47SJoerg Sonnenberger }
1381e9a6b47SJoerg Sonnenberger
1391e9a6b47SJoerg Sonnenberger #if defined(_WIN32_WCE)
1401e9a6b47SJoerg Sonnenberger /* The Microsoft C Run-Time Library for Windows CE doesn't have
1411e9a6b47SJoerg Sonnenberger * errno. We define it as a global variable to simplify porting.
1421e9a6b47SJoerg Sonnenberger * Its value is always 0 and should not be used.
1431e9a6b47SJoerg Sonnenberger */
1441e9a6b47SJoerg Sonnenberger int errno = 0;
1451e9a6b47SJoerg Sonnenberger #endif
1461e9a6b47SJoerg Sonnenberger
1471e9a6b47SJoerg Sonnenberger #ifndef HAVE_MEMCPY
1481e9a6b47SJoerg Sonnenberger
zmemcpy(dest,source,len)149fe927c51SPeter Avalos void ZLIB_INTERNAL zmemcpy(dest, source, len)
1501e9a6b47SJoerg Sonnenberger Bytef* dest;
1511e9a6b47SJoerg Sonnenberger const Bytef* source;
1521e9a6b47SJoerg Sonnenberger uInt len;
1531e9a6b47SJoerg Sonnenberger {
1541e9a6b47SJoerg Sonnenberger if (len == 0) return;
1551e9a6b47SJoerg Sonnenberger do {
1561e9a6b47SJoerg Sonnenberger *dest++ = *source++; /* ??? to be unrolled */
1571e9a6b47SJoerg Sonnenberger } while (--len != 0);
1581e9a6b47SJoerg Sonnenberger }
1591e9a6b47SJoerg Sonnenberger
zmemcmp(s1,s2,len)160fe927c51SPeter Avalos int ZLIB_INTERNAL zmemcmp(s1, s2, len)
1611e9a6b47SJoerg Sonnenberger const Bytef* s1;
1621e9a6b47SJoerg Sonnenberger const Bytef* s2;
1631e9a6b47SJoerg Sonnenberger uInt len;
1641e9a6b47SJoerg Sonnenberger {
1651e9a6b47SJoerg Sonnenberger uInt j;
1661e9a6b47SJoerg Sonnenberger
1671e9a6b47SJoerg Sonnenberger for (j = 0; j < len; j++) {
1681e9a6b47SJoerg Sonnenberger if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
1691e9a6b47SJoerg Sonnenberger }
1701e9a6b47SJoerg Sonnenberger return 0;
1711e9a6b47SJoerg Sonnenberger }
1721e9a6b47SJoerg Sonnenberger
zmemzero(dest,len)173fe927c51SPeter Avalos void ZLIB_INTERNAL zmemzero(dest, len)
1741e9a6b47SJoerg Sonnenberger Bytef* dest;
1751e9a6b47SJoerg Sonnenberger uInt len;
1761e9a6b47SJoerg Sonnenberger {
1771e9a6b47SJoerg Sonnenberger if (len == 0) return;
1781e9a6b47SJoerg Sonnenberger do {
1791e9a6b47SJoerg Sonnenberger *dest++ = 0; /* ??? to be unrolled */
1801e9a6b47SJoerg Sonnenberger } while (--len != 0);
1811e9a6b47SJoerg Sonnenberger }
1821e9a6b47SJoerg Sonnenberger #endif
1831e9a6b47SJoerg Sonnenberger
184712f98b7SJohn Marino #ifndef Z_SOLO
1851e9a6b47SJoerg Sonnenberger
1861e9a6b47SJoerg Sonnenberger #ifdef SYS16BIT
1871e9a6b47SJoerg Sonnenberger
1881e9a6b47SJoerg Sonnenberger #ifdef __TURBOC__
1891e9a6b47SJoerg Sonnenberger /* Turbo C in 16-bit mode */
1901e9a6b47SJoerg Sonnenberger
1911e9a6b47SJoerg Sonnenberger # define MY_ZCALLOC
1921e9a6b47SJoerg Sonnenberger
1931e9a6b47SJoerg Sonnenberger /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
1941e9a6b47SJoerg Sonnenberger * and farmalloc(64K) returns a pointer with an offset of 8, so we
1951e9a6b47SJoerg Sonnenberger * must fix the pointer. Warning: the pointer must be put back to its
1961e9a6b47SJoerg Sonnenberger * original form in order to free it, use zcfree().
1971e9a6b47SJoerg Sonnenberger */
1981e9a6b47SJoerg Sonnenberger
1991e9a6b47SJoerg Sonnenberger #define MAX_PTR 10
2001e9a6b47SJoerg Sonnenberger /* 10*64K = 640K */
2011e9a6b47SJoerg Sonnenberger
2021e9a6b47SJoerg Sonnenberger local int next_ptr = 0;
2031e9a6b47SJoerg Sonnenberger
2041e9a6b47SJoerg Sonnenberger typedef struct ptr_table_s {
2051e9a6b47SJoerg Sonnenberger voidpf org_ptr;
2061e9a6b47SJoerg Sonnenberger voidpf new_ptr;
2071e9a6b47SJoerg Sonnenberger } ptr_table;
2081e9a6b47SJoerg Sonnenberger
2091e9a6b47SJoerg Sonnenberger local ptr_table table[MAX_PTR];
2101e9a6b47SJoerg Sonnenberger /* This table is used to remember the original form of pointers
2111e9a6b47SJoerg Sonnenberger * to large buffers (64K). Such pointers are normalized with a zero offset.
2121e9a6b47SJoerg Sonnenberger * Since MSDOS is not a preemptive multitasking OS, this table is not
2131e9a6b47SJoerg Sonnenberger * protected from concurrent access. This hack doesn't work anyway on
2141e9a6b47SJoerg Sonnenberger * a protected system like OS/2. Use Microsoft C instead.
2151e9a6b47SJoerg Sonnenberger */
2161e9a6b47SJoerg Sonnenberger
zcalloc(voidpf opaque,unsigned items,unsigned size)217fe927c51SPeter Avalos voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
2181e9a6b47SJoerg Sonnenberger {
219*e041647aSSascha Wildner voidpf buf;
2201e9a6b47SJoerg Sonnenberger ulg bsize = (ulg)items*size;
2211e9a6b47SJoerg Sonnenberger
222*e041647aSSascha Wildner (void)opaque;
223*e041647aSSascha Wildner
2241e9a6b47SJoerg Sonnenberger /* If we allocate less than 65520 bytes, we assume that farmalloc
2251e9a6b47SJoerg Sonnenberger * will return a usable pointer which doesn't have to be normalized.
2261e9a6b47SJoerg Sonnenberger */
2271e9a6b47SJoerg Sonnenberger if (bsize < 65520L) {
2281e9a6b47SJoerg Sonnenberger buf = farmalloc(bsize);
2291e9a6b47SJoerg Sonnenberger if (*(ush*)&buf != 0) return buf;
2301e9a6b47SJoerg Sonnenberger } else {
2311e9a6b47SJoerg Sonnenberger buf = farmalloc(bsize + 16L);
2321e9a6b47SJoerg Sonnenberger }
2331e9a6b47SJoerg Sonnenberger if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
2341e9a6b47SJoerg Sonnenberger table[next_ptr].org_ptr = buf;
2351e9a6b47SJoerg Sonnenberger
2361e9a6b47SJoerg Sonnenberger /* Normalize the pointer to seg:0 */
2371e9a6b47SJoerg Sonnenberger *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
2381e9a6b47SJoerg Sonnenberger *(ush*)&buf = 0;
2391e9a6b47SJoerg Sonnenberger table[next_ptr++].new_ptr = buf;
2401e9a6b47SJoerg Sonnenberger return buf;
2411e9a6b47SJoerg Sonnenberger }
2421e9a6b47SJoerg Sonnenberger
zcfree(voidpf opaque,voidpf ptr)243fe927c51SPeter Avalos void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
2441e9a6b47SJoerg Sonnenberger {
2451e9a6b47SJoerg Sonnenberger int n;
246*e041647aSSascha Wildner
247*e041647aSSascha Wildner (void)opaque;
248*e041647aSSascha Wildner
2491e9a6b47SJoerg Sonnenberger if (*(ush*)&ptr != 0) { /* object < 64K */
2501e9a6b47SJoerg Sonnenberger farfree(ptr);
2511e9a6b47SJoerg Sonnenberger return;
2521e9a6b47SJoerg Sonnenberger }
2531e9a6b47SJoerg Sonnenberger /* Find the original pointer */
2541e9a6b47SJoerg Sonnenberger for (n = 0; n < next_ptr; n++) {
2551e9a6b47SJoerg Sonnenberger if (ptr != table[n].new_ptr) continue;
2561e9a6b47SJoerg Sonnenberger
2571e9a6b47SJoerg Sonnenberger farfree(table[n].org_ptr);
2581e9a6b47SJoerg Sonnenberger while (++n < next_ptr) {
2591e9a6b47SJoerg Sonnenberger table[n-1] = table[n];
2601e9a6b47SJoerg Sonnenberger }
2611e9a6b47SJoerg Sonnenberger next_ptr--;
2621e9a6b47SJoerg Sonnenberger return;
2631e9a6b47SJoerg Sonnenberger }
2641e9a6b47SJoerg Sonnenberger Assert(0, "zcfree: ptr not found");
2651e9a6b47SJoerg Sonnenberger }
2661e9a6b47SJoerg Sonnenberger
2671e9a6b47SJoerg Sonnenberger #endif /* __TURBOC__ */
2681e9a6b47SJoerg Sonnenberger
2691e9a6b47SJoerg Sonnenberger
2701e9a6b47SJoerg Sonnenberger #ifdef M_I86
2711e9a6b47SJoerg Sonnenberger /* Microsoft C in 16-bit mode */
2721e9a6b47SJoerg Sonnenberger
2731e9a6b47SJoerg Sonnenberger # define MY_ZCALLOC
2741e9a6b47SJoerg Sonnenberger
2751e9a6b47SJoerg Sonnenberger #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
2761e9a6b47SJoerg Sonnenberger # define _halloc halloc
2771e9a6b47SJoerg Sonnenberger # define _hfree hfree
2781e9a6b47SJoerg Sonnenberger #endif
2791e9a6b47SJoerg Sonnenberger
zcalloc(voidpf opaque,uInt items,uInt size)280fe927c51SPeter Avalos voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
2811e9a6b47SJoerg Sonnenberger {
282*e041647aSSascha Wildner (void)opaque;
2831e9a6b47SJoerg Sonnenberger return _halloc((long)items, size);
2841e9a6b47SJoerg Sonnenberger }
2851e9a6b47SJoerg Sonnenberger
zcfree(voidpf opaque,voidpf ptr)286fe927c51SPeter Avalos void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
2871e9a6b47SJoerg Sonnenberger {
288*e041647aSSascha Wildner (void)opaque;
2891e9a6b47SJoerg Sonnenberger _hfree(ptr);
2901e9a6b47SJoerg Sonnenberger }
2911e9a6b47SJoerg Sonnenberger
2921e9a6b47SJoerg Sonnenberger #endif /* M_I86 */
2931e9a6b47SJoerg Sonnenberger
2941e9a6b47SJoerg Sonnenberger #endif /* SYS16BIT */
2951e9a6b47SJoerg Sonnenberger
2961e9a6b47SJoerg Sonnenberger
2971e9a6b47SJoerg Sonnenberger #ifndef MY_ZCALLOC /* Any system without a special alloc function */
2981e9a6b47SJoerg Sonnenberger
2991e9a6b47SJoerg Sonnenberger #ifndef STDC
3001e9a6b47SJoerg Sonnenberger extern voidp malloc OF((uInt size));
3011e9a6b47SJoerg Sonnenberger extern voidp calloc OF((uInt items, uInt size));
3021e9a6b47SJoerg Sonnenberger extern void free OF((voidpf ptr));
3031e9a6b47SJoerg Sonnenberger #endif
3041e9a6b47SJoerg Sonnenberger
zcalloc(opaque,items,size)305fe927c51SPeter Avalos voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
3061e9a6b47SJoerg Sonnenberger voidpf opaque;
3071e9a6b47SJoerg Sonnenberger unsigned items;
3081e9a6b47SJoerg Sonnenberger unsigned size;
3091e9a6b47SJoerg Sonnenberger {
310*e041647aSSascha Wildner (void)opaque;
3111e9a6b47SJoerg Sonnenberger return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
3121e9a6b47SJoerg Sonnenberger (voidpf)calloc(items, size);
3131e9a6b47SJoerg Sonnenberger }
3141e9a6b47SJoerg Sonnenberger
zcfree(opaque,ptr)315fe927c51SPeter Avalos void ZLIB_INTERNAL zcfree (opaque, ptr)
3161e9a6b47SJoerg Sonnenberger voidpf opaque;
3171e9a6b47SJoerg Sonnenberger voidpf ptr;
3181e9a6b47SJoerg Sonnenberger {
319*e041647aSSascha Wildner (void)opaque;
3201e9a6b47SJoerg Sonnenberger free(ptr);
3211e9a6b47SJoerg Sonnenberger }
3221e9a6b47SJoerg Sonnenberger
3231e9a6b47SJoerg Sonnenberger #endif /* MY_ZCALLOC */
324712f98b7SJohn Marino
325712f98b7SJohn Marino #endif /* !Z_SOLO */
326