varnish-cache/lib/libvgz/zutil.c
0
/* zutil.c -- target dependent utility functions for the compression library
1
 * Copyright (C) 1995-2017 Jean-loup Gailly
2
 * For conditions of distribution and use, see copyright notice in zlib.h
3
 */
4
5
/* @(#) $Id$ */
6
7
#include "zutil.h"
8
#ifndef Z_SOLO
9
#  include "gzguts.h"
10
#endif
11
12
z_const char * const z_errmsg[10] = {
13
    (z_const char *)"need dictionary",     /* Z_NEED_DICT       2  */
14
    (z_const char *)"stream end",          /* Z_STREAM_END      1  */
15
    (z_const char *)"",                    /* Z_OK              0  */
16
    (z_const char *)"file error",          /* Z_ERRNO         (-1) */
17
    (z_const char *)"stream error",        /* Z_STREAM_ERROR  (-2) */
18
    (z_const char *)"data error",          /* Z_DATA_ERROR    (-3) */
19
    (z_const char *)"insufficient memory", /* Z_MEM_ERROR     (-4) */
20
    (z_const char *)"buffer error",        /* Z_BUF_ERROR     (-5) */
21
    (z_const char *)"incompatible version",/* Z_VERSION_ERROR (-6) */
22
    (z_const char *)""
23
};
24
25
#ifdef NOVGZ
26
27
const char * ZEXPORT zlibVersion()
28
{
29
    return ZLIB_VERSION;
30
}
31
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
#if defined(ASMV) || defined(ASMINF)
65
    flags += 1 << 9;
66
#endif
67
#ifdef ZLIB_WINAPI
68
    flags += 1 << 10;
69
#endif
70
#ifdef BUILDFIXED
71
    flags += 1 << 12;
72
#endif
73
#ifdef DYNAMIC_CRC_TABLE
74
    flags += 1 << 13;
75
#endif
76
#ifdef NO_GZCOMPRESS
77
    flags += 1L << 16;
78
#endif
79
#ifdef NO_GZIP
80
    flags += 1L << 17;
81
#endif
82
#ifdef PKZIP_BUG_WORKAROUND
83
    flags += 1L << 20;
84
#endif
85
#ifdef FASTEST
86
    flags += 1L << 21;
87
#endif
88
#if defined(STDC) || defined(Z_HAVE_STDARG_H)
89
#  ifdef NO_vsnprintf
90
    flags += 1L << 25;
91
#    ifdef HAS_vsprintf_void
92
    flags += 1L << 26;
93
#    endif
94
#  else
95
#    ifdef HAS_vsnprintf_void
96
    flags += 1L << 26;
97
#    endif
98
#  endif
99
#else
100
    flags += 1L << 24;
101
#  ifdef NO_snprintf
102
    flags += 1L << 25;
103
#    ifdef HAS_sprintf_void
104
    flags += 1L << 26;
105
#    endif
106
#  else
107
#    ifdef HAS_snprintf_void
108
    flags += 1L << 26;
109
#    endif
110
#  endif
111
#endif
112
    return flags;
113
}
114
115
#ifdef ZLIB_DEBUG
116
#include <stdlib.h>
117
#  ifndef verbose
118
#    define verbose 0
119
#  endif
120
int ZLIB_INTERNAL z_verbose = verbose;
121
122
void ZLIB_INTERNAL z_error (m)
123
    char *m;
124
{
125
    fprintf(stderr, "%s\n", m);
126
    exit(1);
127
}
128
#endif
129
130
/* exported to allow conversion of error code to string for compress() and
131
 * uncompress()
132
 */
133
const char * ZEXPORT zError(err)
134
    int err;
135
{
136
    return ERR_MSG(err);
137
}
138
139
#if defined(_WIN32_WCE) && _WIN32_WCE < 0x800
140
    /* The older Microsoft C Run-Time Library for Windows CE doesn't have
141
     * errno.  We define it as a global variable to simplify porting.
142
     * Its value is always 0 and should not be used.
143
     */
144
    int errno = 0;
145
#endif
146
147
#ifndef HAVE_MEMCPY
148
149
void ZLIB_INTERNAL zmemcpy(dest, source, len)
150
    Bytef* dest;
151
    const Bytef* source;
152
    uInt  len;
153
{
154
    if (len == 0) return;
155
    do {
156
        *dest++ = *source++; /* ??? to be unrolled */
157
    } while (--len != 0);
158
}
159
160
int ZLIB_INTERNAL zmemcmp(s1, s2, len)
161
    const Bytef* s1;
162
    const Bytef* s2;
163
    uInt  len;
164
{
165
    uInt j;
166
167
    for (j = 0; j < len; j++) {
168
        if (s1[j] != s2[j]) return 2*(s1[j] > s2[j])-1;
169
    }
170
    return 0;
171
}
172
173
void ZLIB_INTERNAL zmemzero(dest, len)
174
    Bytef* dest;
175
    uInt  len;
176
{
177
    if (len == 0) return;
178
    do {
179
        *dest++ = 0;  /* ??? to be unrolled */
180
    } while (--len != 0);
181
}
182
#endif
183
184
#endif /* NOVGZ */
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
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
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
282
voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
283
{
284
    (void)opaque;
285
    return _halloc((long)items, size);
286
}
287
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
307 4803
voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
308
    voidpf opaque;
309
    unsigned items;
310
    unsigned size;
311
{
312 4803
    (void)opaque;
313 4803
    return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
314
                              (voidpf)calloc(items, size);
315
}
316
317 4803
void ZLIB_INTERNAL zcfree (opaque, ptr)
318
    voidpf opaque;
319
    voidpf ptr;
320
{
321 4803
    (void)opaque;
322 4803
    free(ptr);
323 4803
}
324
325
#endif /* MY_ZCALLOC */
326
327
#endif /* !Z_SOLO */