usr/src/uts/common/zmod/zutil.c

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