Annotation of embedaddon/sudo/zlib/zutil.c, revision 1.1.1.1

1.1       misho       1: /* zutil.c -- target dependent utility functions for the compression library
                      2:  * Copyright (C) 1995-2005, 2010 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: 
                     10: #ifndef NO_DUMMY_DECL
                     11: struct internal_state      {int dummy;}; /* for buggy compilers */
                     12: #endif
                     13: 
                     14: const char * const z_errmsg[10] = {
                     15: "need dictionary",     /* Z_NEED_DICT       2  */
                     16: "stream end",          /* Z_STREAM_END      1  */
                     17: "",                    /* Z_OK              0  */
                     18: "file error",          /* Z_ERRNO         (-1) */
                     19: "stream error",        /* Z_STREAM_ERROR  (-2) */
                     20: "data error",          /* Z_DATA_ERROR    (-3) */
                     21: "insufficient memory", /* Z_MEM_ERROR     (-4) */
                     22: "buffer error",        /* Z_BUF_ERROR     (-5) */
                     23: "incompatible version",/* Z_VERSION_ERROR (-6) */
                     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 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: #ifdef STDC
                     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 DEBUG
                    116: 
                    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: 
                    185: #ifdef SYS16BIT
                    186: 
                    187: #ifdef __TURBOC__
                    188: /* Turbo C in 16-bit mode */
                    189: 
                    190: #  define MY_ZCALLOC
                    191: 
                    192: /* Turbo C malloc() does not allow dynamic allocation of 64K bytes
                    193:  * and farmalloc(64K) returns a pointer with an offset of 8, so we
                    194:  * must fix the pointer. Warning: the pointer must be put back to its
                    195:  * original form in order to free it, use zcfree().
                    196:  */
                    197: 
                    198: #define MAX_PTR 10
                    199: /* 10*64K = 640K */
                    200: 
                    201: local int next_ptr = 0;
                    202: 
                    203: typedef struct ptr_table_s {
                    204:     voidpf org_ptr;
                    205:     voidpf new_ptr;
                    206: } ptr_table;
                    207: 
                    208: local ptr_table table[MAX_PTR];
                    209: /* This table is used to remember the original form of pointers
                    210:  * to large buffers (64K). Such pointers are normalized with a zero offset.
                    211:  * Since MSDOS is not a preemptive multitasking OS, this table is not
                    212:  * protected from concurrent access. This hack doesn't work anyway on
                    213:  * a protected system like OS/2. Use Microsoft C instead.
                    214:  */
                    215: 
                    216: voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, unsigned items, unsigned size)
                    217: {
                    218:     voidpf buf = opaque; /* just to make some compilers happy */
                    219:     ulg bsize = (ulg)items*size;
                    220: 
                    221:     /* If we allocate less than 65520 bytes, we assume that farmalloc
                    222:      * will return a usable pointer which doesn't have to be normalized.
                    223:      */
                    224:     if (bsize < 65520L) {
                    225:         buf = farmalloc(bsize);
                    226:         if (*(ush*)&buf != 0) return buf;
                    227:     } else {
                    228:         buf = farmalloc(bsize + 16L);
                    229:     }
                    230:     if (buf == NULL || next_ptr >= MAX_PTR) return NULL;
                    231:     table[next_ptr].org_ptr = buf;
                    232: 
                    233:     /* Normalize the pointer to seg:0 */
                    234:     *((ush*)&buf+1) += ((ush)((uch*)buf-0) + 15) >> 4;
                    235:     *(ush*)&buf = 0;
                    236:     table[next_ptr++].new_ptr = buf;
                    237:     return buf;
                    238: }
                    239: 
                    240: void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
                    241: {
                    242:     int n;
                    243:     if (*(ush*)&ptr != 0) { /* object < 64K */
                    244:         farfree(ptr);
                    245:         return;
                    246:     }
                    247:     /* Find the original pointer */
                    248:     for (n = 0; n < next_ptr; n++) {
                    249:         if (ptr != table[n].new_ptr) continue;
                    250: 
                    251:         farfree(table[n].org_ptr);
                    252:         while (++n < next_ptr) {
                    253:             table[n-1] = table[n];
                    254:         }
                    255:         next_ptr--;
                    256:         return;
                    257:     }
                    258:     ptr = opaque; /* just to make some compilers happy */
                    259:     Assert(0, "zcfree: ptr not found");
                    260: }
                    261: 
                    262: #endif /* __TURBOC__ */
                    263: 
                    264: 
                    265: #ifdef M_I86
                    266: /* Microsoft C in 16-bit mode */
                    267: 
                    268: #  define MY_ZCALLOC
                    269: 
                    270: #if (!defined(_MSC_VER) || (_MSC_VER <= 600))
                    271: #  define _halloc  halloc
                    272: #  define _hfree   hfree
                    273: #endif
                    274: 
                    275: voidpf ZLIB_INTERNAL zcalloc (voidpf opaque, uInt items, uInt size)
                    276: {
                    277:     if (opaque) opaque = 0; /* to make compiler happy */
                    278:     return _halloc((long)items, size);
                    279: }
                    280: 
                    281: void ZLIB_INTERNAL zcfree (voidpf opaque, voidpf ptr)
                    282: {
                    283:     if (opaque) opaque = 0; /* to make compiler happy */
                    284:     _hfree(ptr);
                    285: }
                    286: 
                    287: #endif /* M_I86 */
                    288: 
                    289: #endif /* SYS16BIT */
                    290: 
                    291: 
                    292: #ifndef MY_ZCALLOC /* Any system without a special alloc function */
                    293: 
                    294: #ifndef STDC
                    295: extern voidp  malloc OF((uInt size));
                    296: extern voidp  calloc OF((uInt items, uInt size));
                    297: extern void   free   OF((voidpf ptr));
                    298: #endif
                    299: 
                    300: voidpf ZLIB_INTERNAL zcalloc (opaque, items, size)
                    301:     voidpf opaque;
                    302:     unsigned items;
                    303:     unsigned size;
                    304: {
                    305:     if (opaque) items += size - size; /* make compiler happy */
                    306:     return sizeof(uInt) > 2 ? (voidpf)malloc(items * size) :
                    307:                               (voidpf)calloc(items, size);
                    308: }
                    309: 
                    310: void ZLIB_INTERNAL zcfree (opaque, ptr)
                    311:     voidpf opaque;
                    312:     voidpf ptr;
                    313: {
                    314:     free(ptr);
                    315:     if (opaque) return; /* make compiler happy */
                    316: }
                    317: 
                    318: #endif /* MY_ZCALLOC */

FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>