"Fossies" - the Fresh Open Source Software Archive

Member "src/Common/zlib/zutil.c" (10 Oct 2018, 7304 Bytes) of package /windows/misc/VeraCrypt_1.23-Hotfix-2_Source.zip:


As a special service "Fossies" has tried to format the requested source page into HTML format using (guessed) C and C++ source code syntax highlighting (style: standard) with prefixed line numbers and code folding option. Alternatively you can here view or download the uninterpreted source code file. For more information about "zutil.c" see the Fossies "Dox" file reference documentation.

    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 
   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)
  140     /* The 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 #ifndef Z_SOLO
  185 
  186 #ifdef SYS16BIT
  187 
  188 #ifdef __TURBOC__
  189 /* Turbo C in 16-bit mode */
  190 
  191 #  define MY_ZCALLOC
  192 
  193 /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
  194  * and farmalloc(64K) returns a pointer with an offset of 8, so we
  195  * must fix the pointer. Warning: the pointer must be put back to its
  196  * original form in order to free it, use zcfree().
  197  */
  198 
  199 #define MAX_PTR 10
  200 /* 10*64K = 640K */
  201 
  202 local int next_ptr = 0;
  203 
  204 typedef struct ptr_table_s {
  205     voidpf org_ptr;
  206     voidpf new_ptr;
  207 } ptr_table;
  208 
  209 local ptr_table table[MAX_PTR];
  210 /* This table is used to remember the original form of pointers
  211  * to large buffers (64K). Such pointers are normalized with a zero offset.
  212  * Since MSDOS is not a preemptive multitasking OS, this table is not
  213  * protected from concurrent access. This hack doesn't work anyway on
  214  * a protected system like OS/2. Use Microsoft C instead.
  215  */
  216 
  217 voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
  218 {
  219     voidpf buf;
  220     ulg bsize = (ulg)items*size;
  221 
  222     (void)opaque;
  223 
  224     /* If we allocate less than 65520 bytes, we assume that farmalloc
  225      * will return a usable pointer which doesn't have to be normalized.
  226      */
  227     if (bsize < 65520L) {
  228         buf = farmalloc(bsize);
  229         if (*(ush*)&buf != 0) return buf;
  230     } else {
  231         buf = farmalloc(bsize + 16L);
  232     }
  233     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
  234     table[next_ptr].org_ptr = buf;
  235 
  236     /* Normalize the pointer to seg:0 */
  237     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
  238     *(ush*)&buf = 0;
  239     table[next_ptr++].new_ptr = buf;
  240     return buf;
  241 }
  242 
  243 void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
  244 {
  245     int n;
  246 
  247     (void)opaque;
  248 
  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     Assert(0, "zcfree: ptr not found");
  265 }
  266 
  267 #endif /* __TURBOC__ */
  268 
  269 
  270 #ifdef M_I86
  271 /* Microsoft C in 16-bit mode */
  272 
  273 #  define MY_ZCALLOC
  274 
  275 #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
  276 #  define _halloc  halloc
  277 #  define _hfree   hfree
  278 #endif
  279 
  280 voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
  281 {
  282     (void)opaque;
  283     return _halloc((long)items, size);
  284 }
  285 
  286 void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
  287 {
  288     (void)opaque;
  289     _hfree(ptr);
  290 }
  291 
  292 #endif /* M_I86 */
  293 
  294 #endif /* SYS16BIT */
  295 
  296 
  297 #ifndef MY_ZCALLOC /* Any system without a special alloc function */
  298 
  299 #ifndef STDC
  300 extern voidp  malloc OF((uInt size));
  301 extern voidp  calloc OF((uInt items, uInt size));
  302 extern void   free   OF((voidpf ptr));
  303 #endif
  304 
  305 voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
  306     voidpf opaque;
  307     unsigned items;
  308     unsigned size;
  309 {
  310     (void)opaque;
  311     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
  312                               (voidpf)calloc(items, size);
  313 }
  314 
  315 void ZLIB_INTERNAL zcfree (opaque, ptr)
  316     voidpf opaque;
  317     voidpf ptr;
  318 {
  319     (void)opaque;
  320     free(ptr);
  321 }
  322 
  323 #endif /* MY_ZCALLOC */
  324 
  325 #endif /* !Z_SOLO */