1 /* zutil.c -- target dependent utility functions for the compression library
2  * Copyright (C) 1995-2017 Jean-loup Gailly
3  * For conditions of distribution and use, see copyright notice in zlib.h
4  */
5 
6 /* @(#) $Id$ */
7 
8 #include "zutil.h"
9 #ifndef Z_SOLO
10 #  include "gzguts.h"
11 #endif
12 
13 z_const char * const z_errmsg[10] = {
14     (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */
15     (z_const char *)"stream end",          /* Z_STREAM_END      1  */
16     (z_const char *)"",                    /* Z_OK              0  */
17     (z_const char *)"file error",          /* Z_ERRNO         (-1) */
18     (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */
19     (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */
20     (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */
21     (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */
22     (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
23     (z_const char *)""
24 };
25 
26 
zlibVersion()27 const char * ZEXPORT zlibVersion()
28 {
29     return ZLIB_VERSION;
30 }
31 
zlibCompileFlags()32 uLong ZEXPORT zlibCompileFlags()
33 {
34     uLong flags;
35 
36     flags = 0;
37     switch ((int)(sizeof(uInt))) {
38     case 2:     break;
39     case 4:     flags += 1;     break;
40     case 8:     flags += 2;     break;
41     default:    flags += 3;
42     }
43     switch ((int)(sizeof(uLong))) {
44     case 2:     break;
45     case 4:     flags += 1 << 2;        break;
46     case 8:     flags += 2 << 2;        break;
47     default:    flags += 3 << 2;
48     }
49     switch ((int)(sizeof(voidpf))) {
50     case 2:     break;
51     case 4:     flags += 1 << 4;        break;
52     case 8:     flags += 2 << 4;        break;
53     default:    flags += 3 << 4;
54     }
55     switch ((int)(sizeof(z_off_t))) {
56     case 2:     break;
57     case 4:     flags += 1 << 6;        break;
58     case 8:     flags += 2 << 6;        break;
59     default:    flags += 3 << 6;
60     }
61 #ifdef ZLIB_DEBUG
62     flags += 1 << 8;
63 #endif
64     /*
65 #if defined(ASMV) || defined(ASMINF)
66     flags += 1 << 9;
67 #endif
68      */
69 #ifdef ZLIB_WINAPI
70     flags += 1 << 10;
71 #endif
72 #ifdef BUILDFIXED
73     flags += 1 << 12;
74 #endif
75 #ifdef DYNAMIC_CRC_TABLE
76     flags += 1 << 13;
77 #endif
78 #ifdef NO_GZCOMPRESS
79     flags += 1L << 16;
80 #endif
81 #ifdef NO_GZIP
82     flags += 1L << 17;
83 #endif
84 #ifdef PKZIP_BUG_WORKAROUND
85     flags += 1L << 20;
86 #endif
87 #ifdef FASTEST
88     flags += 1L << 21;
89 #endif
90 #if defined(STDC) || defined(Z_HAVE_STDARG_H)
91 #  ifdef NO_vsnprintf
92     flags += 1L << 25;
93 #    ifdef HAS_vsprintf_void
94     flags += 1L << 26;
95 #    endif
96 #  else
97 #    ifdef HAS_vsnprintf_void
98     flags += 1L << 26;
99 #    endif
100 #  endif
101 #else
102     flags += 1L << 24;
103 #  ifdef NO_snprintf
104     flags += 1L << 25;
105 #    ifdef HAS_sprintf_void
106     flags += 1L << 26;
107 #    endif
108 #  else
109 #    ifdef HAS_snprintf_void
110     flags += 1L << 26;
111 #    endif
112 #  endif
113 #endif
114     return flags;
115 }
116 
117 #ifdef ZLIB_DEBUG
118 #include <stdlib.h>
119 #  ifndef verbose
120 #    define verbose 0
121 #  endif
122 int ZLIB_INTERNAL z_verbose = verbose;
123 
z_error(m)124 void ZLIB_INTERNAL z_error(m)
125     char *m;
126 {
127     fprintf(stderr, "%s\n", m);
128     exit(1);
129 }
130 #endif
131 
132 /* exported to allow conversion of error code to string for compress() and
133  * uncompress()
134  */
zError(err)135 const char * ZEXPORT zError(err)
136     int err;
137 {
138     return ERR_MSG(err);
139 }
140 
141 #if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
142     /* The older Microsoft C Run-Time Library for Windows CE doesn't have
143      * errno.  We define it as a global variable to simplify porting.
144      * Its value is always 0 and should not be used.
145      */
146     int errno = 0;
147 #endif
148 
149 #ifndef HAVE_MEMCPY
150 
zmemcpy(dest,source,len)151 void ZLIB_INTERNAL zmemcpy(dest, source, len)
152     Bytef* dest;
153     const Bytef* source;
154     uInt  len;
155 {
156     if (len == 0) return;
157     do {
158         *dest++ = *source++; /* ??? to be unrolled */
159     } while (--len != 0);
160 }
161 
zmemcmp(s1,s2,len)162 int ZLIB_INTERNAL zmemcmp(s1, s2, len)
163     const Bytef* s1;
164     const Bytef* s2;
165     uInt  len;
166 {
167     uInt j;
168 
169     for (j = 0; j < len; j++) {
170         if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
171     }
172     return 0;
173 }
174 
zmemzero(dest,len)175 void ZLIB_INTERNAL zmemzero(dest, len)
176     Bytef* dest;
177     uInt  len;
178 {
179     if (len == 0) return;
180     do {
181         *dest++ = 0;  /* ??? to be unrolled */
182     } while (--len != 0);
183 }
184 #endif
185 
186 #ifndef Z_SOLO
187 
188 #ifdef SYS16BIT
189 
190 #ifdef __TURBOC__
191 /* Turbo C in 16-bit mode */
192 
193 #  define MY_ZCALLOC
194 
195 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
196  * and farmalloc(64K) returns a pointer with an offset of 8, so we
197  * must fix the pointer. Warning: the pointer must be put back to its
198  * original form in order to free it, use zcfree().
199  */
200 
201 #define MAX_PTR 10
202 /* 10*64K = 640K */
203 
204 local int next_ptr = 0;
205 
206 typedef struct ptr_table_s {
207     voidpf org_ptr;
208     voidpf new_ptr;
209 } ptr_table;
210 
211 local ptr_table table[MAX_PTR];
212 /* This table is used to remember the original form of pointers
213  * to large buffers (64K). Such pointers are normalized with a zero offset.
214  * Since MSDOS is not a preemptive multitasking OS, this table is not
215  * protected from concurrent access. This hack doesn't work anyway on
216  * a protected system like OS/2. Use Microsoft C instead.
217  */
218 
zcalloc(voidpf opaque,unsigned items,unsigned size)219 voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, unsigned items, unsigned size)
220 {
221     voidpf buf;
222     ulg bsize = (ulg)items*size;
223 
224     (void)opaque;
225 
226     /* If we allocate less than 65520 bytes, we assume that farmalloc
227      * will return a usable pointer which doesn't have to be normalized.
228      */
229     if (bsize < 65520L) {
230         buf = farmalloc(bsize);
231         if (*(ush*)&buf != 0) return buf;
232     } else {
233         buf = farmalloc(bsize + 16L);
234     }
235     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
236     table[next_ptr].org_ptr = buf;
237 
238     /* Normalize the pointer to seg:0 */
239     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
240     *(ush*)&buf = 0;
241     table[next_ptr++].new_ptr = buf;
242     return buf;
243 }
244 
zcfree(voidpf opaque,voidpf ptr)245 void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr)
246 {
247     int n;
248 
249     (void)opaque;
250 
251     if (*(ush*)&ptr != 0) { /* object < 64K */
252         farfree(ptr);
253         return;
254     }
255     /* Find the original pointer */
256     for (n = 0; n < next_ptr; n++) {
257         if (ptr != table[n].new_ptr) continue;
258 
259         farfree(table[n].org_ptr);
260         while (++n < next_ptr) {
261             table[n-1] = table[n];
262         }
263         next_ptr--;
264         return;
265     }
266     Assert(0, "zcfree: ptr not found");
267 }
268 
269 #endif /* __TURBOC__ */
270 
271 
272 #ifdef M_I86
273 /* Microsoft C in 16-bit mode */
274 
275 #  define MY_ZCALLOC
276 
277 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
278 #  define _halloc  halloc
279 #  define _hfree   hfree
280 #endif
281 
zcalloc(voidpf opaque,uInt items,uInt size)282 voidpf ZLIB_INTERNAL zcalloc(voidpf opaque, uInt items, uInt size)
283 {
284     (void)opaque;
285     return _halloc((long)items, size);
286 }
287 
zcfree(voidpf opaque,voidpf ptr)288 void ZLIB_INTERNAL zcfree(voidpf opaque, voidpf ptr)
289 {
290     (void)opaque;
291     _hfree(ptr);
292 }
293 
294 #endif /* M_I86 */
295 
296 #endif /* SYS16BIT */
297 
298 
299 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
300 
301 #ifndef STDC
302 extern voidp  malloc OF((uInt size));
303 extern voidp  calloc OF((uInt items, uInt size));
304 extern void   free   OF((voidpf ptr));
305 #endif
306 
zcalloc(opaque,items,size)307 voidpf ZLIB_INTERNAL zcalloc(opaque, items, size)
308     voidpf opaque;
309     unsigned items;
310     unsigned size;
311 {
312     (void)opaque;
313     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
314                               (voidpf)calloc(items, size);
315 }
316 
zcfree(opaque,ptr)317 void ZLIB_INTERNAL zcfree(opaque, ptr)
318     voidpf opaque;
319     voidpf ptr;
320 {
321     (void)opaque;
322     free(ptr);
323 }
324 
325 #endif /* MY_ZCALLOC */
326 
327 #endif /* !Z_SOLO */
328