1 /*
   2  * Copyright (c) 1995, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 /*
  27  * Support for reading ZIP/JAR files.
  28  */
  29 
  30 #include <stdio.h>
  31 #include <stdlib.h>
  32 #include <stddef.h>
  33 #include <string.h>
  34 #include <fcntl.h>
  35 #include <limits.h>
  36 #include <time.h>
  37 #include <ctype.h>
  38 #include <assert.h>
  39 
  40 #include "jni.h"
  41 #include "jni_util.h"
  42 #include "jlong.h"
  43 #include "jvm.h"
  44 #include "io_util.h"
  45 #include "io_util_md.h"
  46 #include "zip_util.h"
  47 #include "zlib.h"
  48 
  49 #ifdef _ALLBSD_SOURCE
  50 #define off64_t off_t
  51 #define mmap64 mmap
  52 #endif
  53 
  54 /* USE_MMAP means mmap the CEN & ENDHDR part of the zip file. */
  55 #ifdef USE_MMAP
  56 #include <sys/mman.h>
  57 #endif
  58 
  59 #define MAXREFS 0xFFFF  /* max number of open zip file references */
  60 
  61 #define MCREATE()      JVM_RawMonitorCreate()
  62 #define MLOCK(lock)    JVM_RawMonitorEnter(lock)
  63 #define MUNLOCK(lock)  JVM_RawMonitorExit(lock)
  64 #define MDESTROY(lock) JVM_RawMonitorDestroy(lock)
  65 
  66 #define CENSIZE(cen) (CENHDR + CENNAM(cen) + CENEXT(cen) + CENCOM(cen))
  67 
  68 static jzfile *zfiles = 0;      /* currently open zip files */
  69 static void *zfiles_lock = 0;
  70 
  71 static void freeCEN(jzfile *);
  72 
  73 #ifndef PATH_MAX
  74 #define PATH_MAX 1024
  75 #endif
  76 
  77 static jint INITIAL_META_COUNT = 2;   /* initial number of entries in meta name array */
  78 
  79 /*
  80  * The ZFILE_* functions exist to provide some platform-independence with
  81  * respect to file access needs.
  82  */
  83 
  84 /*
  85  * Opens the named file for reading, returning a ZFILE.
  86  *
  87  * Compare this with winFileHandleOpen in windows/native/java/io/io_util_md.c.
  88  * This function does not take JNIEnv* and uses CreateFile (instead of
  89  * CreateFileW).  The expectation is that this function will be called only
  90  * from ZIP_Open_Generic, which in turn is used by the JVM, where we do not
  91  * need to concern ourselves with wide chars.
  92  */
  93 static ZFILE
  94 ZFILE_Open(const char *fname, int flags) {
  95 #ifdef WIN32
  96     const DWORD access =
  97         (flags & O_RDWR)   ? (GENERIC_WRITE | GENERIC_READ) :
  98         (flags & O_WRONLY) ?  GENERIC_WRITE :
  99         GENERIC_READ;
 100     const DWORD sharing =
 101         FILE_SHARE_READ | FILE_SHARE_WRITE;
 102     const DWORD disposition =
 103         /* Note: O_TRUNC overrides O_CREAT */
 104         (flags & O_TRUNC) ? CREATE_ALWAYS :
 105         (flags & O_CREAT) ? OPEN_ALWAYS   :
 106         OPEN_EXISTING;
 107     const DWORD  maybeWriteThrough =
 108         (flags & (O_SYNC | O_DSYNC)) ?
 109         FILE_FLAG_WRITE_THROUGH :
 110         FILE_ATTRIBUTE_NORMAL;
 111     const DWORD maybeDeleteOnClose =
 112         (flags & O_TEMPORARY) ?
 113         FILE_FLAG_DELETE_ON_CLOSE :
 114         FILE_ATTRIBUTE_NORMAL;
 115     const DWORD flagsAndAttributes = maybeWriteThrough | maybeDeleteOnClose;
 116 
 117     return (jlong) CreateFile(
 118         fname,          /* Wide char path name */
 119         access,         /* Read and/or write permission */
 120         sharing,        /* File sharing flags */
 121         NULL,           /* Security attributes */
 122         disposition,        /* creation disposition */
 123         flagsAndAttributes, /* flags and attributes */
 124         NULL);
 125 #else
 126     return JVM_Open(fname, flags, 0);
 127 #endif
 128 }
 129 
 130 /*
 131  * The io_util_md.h files do not provide IO_CLOSE, hence we use platform
 132  * specifics.
 133  */
 134 static void
 135 ZFILE_Close(ZFILE zfd) {
 136 #ifdef WIN32
 137     CloseHandle((HANDLE) zfd);
 138 #else
 139     JVM_Close(zfd);
 140 #endif
 141 }
 142 
 143 static int
 144 ZFILE_read(ZFILE zfd, char *buf, jint nbytes) {
 145 #ifdef WIN32
 146     return (int) IO_Read(zfd, buf, nbytes);
 147 #else
 148     /*
 149      * Calling JVM_Read will return JVM_IO_INTR when Thread.interrupt is called
 150      * only on Solaris. Continue reading jar file in this case is the best
 151      * thing to do since zip file reading is relatively fast and it is very onerous
 152      * for a interrupted thread to deal with this kind of hidden I/O. However, handling
 153      * JVM_IO_INTR is tricky and could cause undesired side effect. So we decided
 154      * to simply call "read" on Solaris/Linux. See details in bug 6304463.
 155      */
 156     return read(zfd, buf, nbytes);
 157 #endif
 158 }
 159 
 160 /*
 161  * Initialize zip file support. Return 0 if successful otherwise -1
 162  * if could not be initialized.
 163  */
 164 static jint
 165 InitializeZip()
 166 {
 167     static jboolean inited = JNI_FALSE;
 168 
 169     // Initialize errno to 0.  It may be set later (e.g. during memory
 170     // allocation) but we can disregard previous values.
 171     errno = 0;
 172 
 173     if (inited)
 174         return 0;
 175     zfiles_lock = MCREATE();
 176     if (zfiles_lock == 0) {
 177         return -1;
 178     }
 179     inited = JNI_TRUE;
 180 
 181     return 0;
 182 }
 183 
 184 /*
 185  * Reads len bytes of data into buf.
 186  * Returns 0 if all bytes could be read, otherwise returns -1.
 187  */
 188 static int
 189 readFully(ZFILE zfd, void *buf, jlong len) {
 190   char *bp = (char *) buf;
 191 
 192   while (len > 0) {
 193         jlong limit = ((((jlong) 1) << 31) - 1);
 194         jint count = (len < limit) ?
 195             (jint) len :
 196             (jint) limit;
 197         jint n = ZFILE_read(zfd, bp, count);
 198         if (n > 0) {
 199             bp += n;
 200             len -= n;
 201         } else if (n == JVM_IO_ERR && errno == EINTR) {
 202           /* Retry after EINTR (interrupted by signal).
 203              We depend on the fact that JVM_IO_ERR == -1. */
 204             continue;
 205         } else { /* EOF or IO error */
 206             return -1;
 207         }
 208     }
 209     return 0;
 210 }
 211 
 212 /*
 213  * Reads len bytes of data from the specified offset into buf.
 214  * Returns 0 if all bytes could be read, otherwise returns -1.
 215  */
 216 static int
 217 readFullyAt(ZFILE zfd, void *buf, jlong len, jlong offset)
 218 {
 219     if (IO_Lseek(zfd, offset, SEEK_SET) == -1) {
 220         return -1; /* lseek failure. */
 221     }
 222 
 223     return readFully(zfd, buf, len);
 224 }
 225 
 226 /*
 227  * Allocates a new zip file object for the specified file name.
 228  * Returns the zip file object or NULL if not enough memory.
 229  */
 230 static jzfile *
 231 allocZip(const char *name)
 232 {
 233     jzfile *zip;
 234     if (((zip = calloc(1, sizeof(jzfile))) != NULL) &&
 235         ((zip->name = strdup(name))        != NULL) &&
 236         ((zip->lock = MCREATE())           != NULL)) {
 237         zip->zfd = -1;
 238         return zip;
 239     }
 240 
 241     if (zip != NULL) {
 242         free(zip->name);
 243         free(zip);
 244     }
 245     return NULL;
 246 }
 247 
 248 /*
 249  * Frees all native resources owned by the specified zip file object.
 250  */
 251 static void
 252 freeZip(jzfile *zip)
 253 {
 254     /* First free any cached jzentry */
 255     ZIP_FreeEntry(zip,0);
 256     if (zip->lock != NULL) MDESTROY(zip->lock);
 257     free(zip->name);
 258     freeCEN(zip);
 259 
 260 #ifdef USE_MMAP
 261     if (zip->usemmap) {
 262         if (zip->maddr != NULL)
 263             munmap((char *)zip->maddr, zip->mlen);
 264     } else
 265 #endif
 266     {
 267         free(zip->cencache.data);
 268     }
 269     if (zip->comment != NULL)
 270         free(zip->comment);
 271     if (zip->zfd != -1) ZFILE_Close(zip->zfd);
 272     free(zip);
 273 }
 274 
 275 /* The END header is followed by a variable length comment of size < 64k. */
 276 static const jlong END_MAXLEN = 0xFFFF + ENDHDR;
 277 
 278 #define READBLOCKSZ 128
 279 
 280 static jboolean verifyEND(jzfile *zip, jlong endpos, char *endbuf) {
 281     /* ENDSIG matched, however the size of file comment in it does not
 282        match the real size. One "common" cause for this problem is some
 283        "extra" bytes are padded at the end of the zipfile.
 284        Let's do some extra verification, we don't care about the performance
 285        in this situation.
 286      */
 287     jlong cenpos = endpos - ENDSIZ(endbuf);
 288     jlong locpos = cenpos - ENDOFF(endbuf);
 289     char buf[4];
 290     return (cenpos >= 0 &&
 291             locpos >= 0 &&
 292             readFullyAt(zip->zfd, buf, sizeof(buf), cenpos) != -1 &&
 293             GETSIG(buf) == CENSIG &&
 294             readFullyAt(zip->zfd, buf, sizeof(buf), locpos) != -1 &&
 295             GETSIG(buf) == LOCSIG);
 296 }
 297 
 298 /*
 299  * Searches for end of central directory (END) header. The contents of
 300  * the END header will be read and placed in endbuf. Returns the file
 301  * position of the END header, otherwise returns -1 if the END header
 302  * was not found or an error occurred.
 303  */
 304 static jlong
 305 findEND(jzfile *zip, void *endbuf)
 306 {
 307     char buf[READBLOCKSZ];
 308     jlong pos;
 309     const jlong len = zip->len;
 310     const ZFILE zfd = zip->zfd;
 311     const jlong minHDR = len - END_MAXLEN > 0 ? len - END_MAXLEN : 0;
 312     const jlong minPos = minHDR - (sizeof(buf)-ENDHDR);
 313     jint clen;
 314 
 315     for (pos = len - sizeof(buf); pos >= minPos; pos -= (sizeof(buf)-ENDHDR)) {
 316 
 317         int i;
 318         jlong off = 0;
 319         if (pos < 0) {
 320             /* Pretend there are some NUL bytes before start of file */
 321             off = -pos;
 322             memset(buf, '\0', (size_t)off);
 323         }
 324 
 325         if (readFullyAt(zfd, buf + off, sizeof(buf) - off,
 326                         pos + off) == -1) {
 327             return -1;  /* System error */
 328         }
 329 
 330         /* Now scan the block backwards for END header signature */
 331         for (i = sizeof(buf) - ENDHDR; i >= 0; i--) {
 332             if (buf[i+0] == 'P'    &&
 333                 buf[i+1] == 'K'    &&
 334                 buf[i+2] == '\005' &&
 335                 buf[i+3] == '\006' &&
 336                 ((pos + i + ENDHDR + ENDCOM(buf + i) == len)
 337                  || verifyEND(zip, pos + i, buf + i))) {
 338                 /* Found END header */
 339                 memcpy(endbuf, buf + i, ENDHDR);
 340 
 341                 clen = ENDCOM(endbuf);
 342                 if (clen != 0) {
 343                     zip->comment = malloc(clen + 1);
 344                     if (zip->comment == NULL) {
 345                         return -1;
 346                     }
 347                     if (readFullyAt(zfd, zip->comment, clen, pos + i + ENDHDR)
 348                         == -1) {
 349                         free(zip->comment);
 350                         zip->comment = NULL;
 351                         return -1;
 352                     }
 353                     zip->comment[clen] = '\0';
 354                     zip->clen = clen;
 355                 }
 356                 return pos + i;
 357             }
 358         }
 359     }
 360 
 361     return -1; /* END header not found */
 362 }
 363 
 364 /*
 365  * Searches for the ZIP64 end of central directory (END) header. The
 366  * contents of the ZIP64 END header will be read and placed in end64buf.
 367  * Returns the file position of the ZIP64 END header, otherwise returns
 368  * -1 if the END header was not found or an error occurred.
 369  *
 370  * The ZIP format specifies the "position" of each related record as
 371  *   ...
 372  *   [central directory]
 373  *   [zip64 end of central directory record]
 374  *   [zip64 end of central directory locator]
 375  *   [end of central directory record]
 376  *
 377  * The offset of zip64 end locator can be calculated from endpos as
 378  * "endpos - ZIP64_LOCHDR".
 379  * The "offset" of zip64 end record is stored in zip64 end locator.
 380  */
 381 static jlong
 382 findEND64(jzfile *zip, void *end64buf, jlong endpos)
 383 {
 384     char loc64[ZIP64_LOCHDR];
 385     jlong end64pos;
 386     if (readFullyAt(zip->zfd, loc64, ZIP64_LOCHDR, endpos - ZIP64_LOCHDR) == -1) {
 387         return -1;    // end64 locator not found
 388     }
 389     end64pos = ZIP64_LOCOFF(loc64);
 390     if (readFullyAt(zip->zfd, end64buf, ZIP64_ENDHDR, end64pos) == -1) {
 391         return -1;    // end64 record not found
 392     }
 393     return end64pos;
 394 }
 395 
 396 /*
 397  * Returns a hash code value for a C-style NUL-terminated string.
 398  */
 399 static unsigned int
 400 hash(const char *s)
 401 {
 402     int h = 0;
 403     while (*s != '\0')
 404         h = 31*h + *s++;
 405     return h;
 406 }
 407 
 408 /*
 409  * Returns a hash code value for a string of a specified length.
 410  */
 411 static unsigned int
 412 hashN(const char *s, int length)
 413 {
 414     int h = 0;
 415     while (length-- > 0)
 416         h = 31*h + *s++;
 417     return h;
 418 }
 419 
 420 static unsigned int
 421 hash_append(unsigned int hash, char c)
 422 {
 423     return ((int)hash)*31 + c;
 424 }
 425 
 426 /*
 427  * Returns true if the specified entry's name begins with the string
 428  * "META-INF/" irrespective of case.
 429  */
 430 static int
 431 isMetaName(const char *name, int length)
 432 {
 433     const char *s;
 434     if (length < (int)sizeof("META-INF/") - 1)
 435         return 0;
 436     for (s = "META-INF/"; *s != '\0'; s++) {
 437         char c = *name++;
 438         // Avoid toupper; it's locale-dependent
 439         if (c >= 'a' && c <= 'z') c += 'A' - 'a';
 440         if (*s != c)
 441             return 0;
 442     }
 443     return 1;
 444 }
 445 
 446 /*
 447  * Increases the capacity of zip->metanames.
 448  * Returns non-zero in case of allocation error.
 449  */
 450 static int
 451 growMetaNames(jzfile *zip)
 452 {
 453     jint i;
 454     /* double the meta names array */
 455     const jint new_metacount = zip->metacount << 1;
 456     zip->metanames =
 457         realloc(zip->metanames, new_metacount * sizeof(zip->metanames[0]));
 458     if (zip->metanames == NULL) return -1;
 459     for (i = zip->metacount; i < new_metacount; i++)
 460         zip->metanames[i] = NULL;
 461     zip->metacurrent = zip->metacount;
 462     zip->metacount = new_metacount;
 463     return 0;
 464 }
 465 
 466 /*
 467  * Adds name to zip->metanames.
 468  * Returns non-zero in case of allocation error.
 469  */
 470 static int
 471 addMetaName(jzfile *zip, const char *name, int length)
 472 {
 473     jint i;
 474     if (zip->metanames == NULL) {
 475       zip->metacount = INITIAL_META_COUNT;
 476       zip->metanames = calloc(zip->metacount, sizeof(zip->metanames[0]));
 477       if (zip->metanames == NULL) return -1;
 478       zip->metacurrent = 0;
 479     }
 480 
 481     i = zip->metacurrent;
 482 
 483     /* current meta name array isn't full yet. */
 484     if (i < zip->metacount) {
 485       zip->metanames[i] = (char *) malloc(length+1);
 486       if (zip->metanames[i] == NULL) return -1;
 487       memcpy(zip->metanames[i], name, length);
 488       zip->metanames[i][length] = '\0';
 489       zip->metacurrent++;
 490       return 0;
 491     }
 492 
 493     /* No free entries in zip->metanames? */
 494     if (growMetaNames(zip) != 0) return -1;
 495     return addMetaName(zip, name, length);
 496 }
 497 
 498 static void
 499 freeMetaNames(jzfile *zip)
 500 {
 501     if (zip->metanames) {
 502         jint i;
 503         for (i = 0; i < zip->metacount; i++)
 504             free(zip->metanames[i]);
 505         free(zip->metanames);
 506         zip->metanames = NULL;
 507     }
 508 }
 509 
 510 /* Free Zip data allocated by readCEN() */
 511 static void
 512 freeCEN(jzfile *zip)
 513 {
 514     free(zip->entries); zip->entries = NULL;
 515     free(zip->table);   zip->table   = NULL;
 516     freeMetaNames(zip);
 517 }
 518 
 519 /*
 520  * Counts the number of CEN headers in a central directory extending
 521  * from BEG to END.  Might return a bogus answer if the zip file is
 522  * corrupt, but will not crash.
 523  */
 524 static jint
 525 countCENHeaders(unsigned char *beg, unsigned char *end)
 526 {
 527     jint count = 0;
 528     ptrdiff_t i;
 529     for (i = 0; i + CENHDR <= end - beg; i += CENSIZE(beg + i))
 530         count++;
 531     return count;
 532 }
 533 
 534 #define ZIP_FORMAT_ERROR(message) \
 535 if (1) { zip->msg = message; goto Catch; } else ((void)0)
 536 
 537 /*
 538  * Reads zip file central directory. Returns the file position of first
 539  * CEN header, otherwise returns -1 if an error occured. If zip->msg != NULL
 540  * then the error was a zip format error and zip->msg has the error text.
 541  * Always pass in -1 for knownTotal; it's used for a recursive call.
 542  */
 543 static jlong
 544 readCEN(jzfile *zip, jint knownTotal)
 545 {
 546     /* Following are unsigned 32-bit */
 547     jlong endpos, end64pos, cenpos, cenlen, cenoff;
 548     /* Following are unsigned 16-bit */
 549     jint total, tablelen, i, j;
 550     unsigned char *cenbuf = NULL;
 551     unsigned char *cenend;
 552     unsigned char *cp;
 553 #ifdef USE_MMAP
 554     static jlong pagesize;
 555     jlong offset;
 556 #endif
 557     unsigned char endbuf[ENDHDR];
 558     jint endhdrlen = ENDHDR;
 559     jzcell *entries;
 560     jint *table;
 561 
 562     /* Clear previous zip error */
 563     zip->msg = NULL;
 564     /* Get position of END header */
 565     if ((endpos = findEND(zip, endbuf)) == -1)
 566         return -1; /* no END header or system error */
 567 
 568     if (endpos == 0) return 0;  /* only END header present */
 569 
 570     freeCEN(zip);
 571    /* Get position and length of central directory */
 572     cenlen = ENDSIZ(endbuf);
 573     cenoff = ENDOFF(endbuf);
 574     total  = ENDTOT(endbuf);
 575     if (cenlen == ZIP64_MAGICVAL || cenoff == ZIP64_MAGICVAL ||
 576         total == ZIP64_MAGICCOUNT) {
 577         unsigned char end64buf[ZIP64_ENDHDR];
 578         if ((end64pos = findEND64(zip, end64buf, endpos)) != -1) {
 579             cenlen = ZIP64_ENDSIZ(end64buf);
 580             cenoff = ZIP64_ENDOFF(end64buf);
 581             total = (jint)ZIP64_ENDTOT(end64buf);
 582             endpos = end64pos;
 583             endhdrlen = ZIP64_ENDHDR;
 584         }
 585     }
 586 
 587     if (cenlen > endpos)
 588         ZIP_FORMAT_ERROR("invalid END header (bad central directory size)");
 589     cenpos = endpos - cenlen;
 590 
 591     /* Get position of first local file (LOC) header, taking into
 592      * account that there may be a stub prefixed to the zip file. */
 593     zip->locpos = cenpos - cenoff;
 594     if (zip->locpos < 0)
 595         ZIP_FORMAT_ERROR("invalid END header (bad central directory offset)");
 596 
 597 #ifdef USE_MMAP
 598     if (zip->usemmap) {
 599       /* On Solaris & Linux prior to JDK 6, we used to mmap the whole jar file to
 600        * read the jar file contents. However, this greatly increased the perceived
 601        * footprint numbers because the mmap'ed pages were adding into the totals shown
 602        * by 'ps' and 'top'. We switched to mmaping only the central directory of jar
 603        * file while calling 'read' to read the rest of jar file. Here are a list of
 604        * reasons apart from above of why we are doing so:
 605        * 1. Greatly reduces mmap overhead after startup complete;
 606        * 2. Avoids dual path code maintainance;
 607        * 3. Greatly reduces risk of address space (not virtual memory) exhaustion.
 608        */
 609         if (pagesize == 0) {
 610             pagesize = (jlong)sysconf(_SC_PAGESIZE);
 611             if (pagesize == 0) goto Catch;
 612         }
 613         if (cenpos > pagesize) {
 614             offset = cenpos & ~(pagesize - 1);
 615         } else {
 616             offset = 0;
 617         }
 618         /* When we are not calling recursively, knownTotal is -1. */
 619         if (knownTotal == -1) {
 620             void* mappedAddr;
 621             /* Mmap the CEN and END part only. We have to figure
 622                out the page size in order to make offset to be multiples of
 623                page size.
 624             */
 625             zip->mlen = cenpos - offset + cenlen + endhdrlen;
 626             zip->offset = offset;
 627             mappedAddr = mmap64(0, zip->mlen, PROT_READ, MAP_SHARED, zip->zfd, (off64_t) offset);
 628             zip->maddr = (mappedAddr == (void*) MAP_FAILED) ? NULL :
 629                 (unsigned char*)mappedAddr;
 630 
 631             if (zip->maddr == NULL) {
 632                 jio_fprintf(stderr, "mmap failed for CEN and END part of zip file\n");
 633                 goto Catch;
 634             }
 635         }
 636         cenbuf = zip->maddr + cenpos - offset;
 637     } else
 638 #endif
 639     {
 640         if ((cenbuf = malloc((size_t) cenlen)) == NULL ||
 641             (readFullyAt(zip->zfd, cenbuf, cenlen, cenpos) == -1))
 642         goto Catch;
 643     }
 644 
 645     cenend = cenbuf + cenlen;
 646 
 647     /* Initialize zip file data structures based on the total number
 648      * of central directory entries as stored in ENDTOT.  Since this
 649      * is a 2-byte field, but we (and other zip implementations)
 650      * support approx. 2**31 entries, we do not trust ENDTOT, but
 651      * treat it only as a strong hint.  When we call ourselves
 652      * recursively, knownTotal will have the "true" value.
 653      *
 654      * Keep this path alive even with the Zip64 END support added, just
 655      * for zip files that have more than 0xffff entries but don't have
 656      * the Zip64 enabled.
 657      */
 658     total = (knownTotal != -1) ? knownTotal : total;
 659     entries  = zip->entries  = calloc(total, sizeof(entries[0]));
 660     tablelen = zip->tablelen = ((total/2) | 1); // Odd -> fewer collisions
 661     table    = zip->table    = malloc(tablelen * sizeof(table[0]));
 662     if (entries == NULL || table == NULL) goto Catch;
 663     for (j = 0; j < tablelen; j++)
 664         table[j] = ZIP_ENDCHAIN;
 665 
 666     /* Iterate through the entries in the central directory */
 667     for (i = 0, cp = cenbuf; cp <= cenend - CENHDR; i++, cp += CENSIZE(cp)) {
 668         /* Following are unsigned 16-bit */
 669         jint method, nlen;
 670         unsigned int hsh;
 671 
 672         if (i >= total) {
 673             /* This will only happen if the zip file has an incorrect
 674              * ENDTOT field, which usually means it contains more than
 675              * 65535 entries. */
 676             cenpos = readCEN(zip, countCENHeaders(cenbuf, cenend));
 677             goto Finally;
 678         }
 679 
 680         method = CENHOW(cp);
 681         nlen   = CENNAM(cp);
 682 
 683         if (GETSIG(cp) != CENSIG)
 684             ZIP_FORMAT_ERROR("invalid CEN header (bad signature)");
 685         if (CENFLG(cp) & 1)
 686             ZIP_FORMAT_ERROR("invalid CEN header (encrypted entry)");
 687         if (method != STORED && method != DEFLATED)
 688             ZIP_FORMAT_ERROR("invalid CEN header (bad compression method)");
 689         if (cp + CENHDR + nlen > cenend)
 690             ZIP_FORMAT_ERROR("invalid CEN header (bad header size)");
 691 
 692         /* if the entry is metadata add it to our metadata names */
 693         if (isMetaName((char *)cp+CENHDR, nlen))
 694             if (addMetaName(zip, (char *)cp+CENHDR, nlen) != 0)
 695                 goto Catch;
 696 
 697         /* Record the CEN offset and the name hash in our hash cell. */
 698         entries[i].cenpos = cenpos + (cp - cenbuf);
 699         entries[i].hash = hashN((char *)cp+CENHDR, nlen);
 700 
 701         /* Add the entry to the hash table */
 702         hsh = entries[i].hash % tablelen;
 703         entries[i].next = table[hsh];
 704         table[hsh] = i;
 705     }
 706     if (cp != cenend)
 707         ZIP_FORMAT_ERROR("invalid CEN header (bad header size)");
 708 
 709     zip->total = i;
 710     goto Finally;
 711 
 712  Catch:
 713     freeCEN(zip);
 714     cenpos = -1;
 715 
 716  Finally:
 717 #ifdef USE_MMAP
 718     if (!zip->usemmap)
 719 #endif
 720         free(cenbuf);
 721 
 722     return cenpos;
 723 }
 724 
 725 /*
 726  * Opens a zip file with the specified mode. Returns the jzfile object
 727  * or NULL if an error occurred. If a zip error occurred then *pmsg will
 728  * be set to the error message text if pmsg != 0. Otherwise, *pmsg will be
 729  * set to NULL. Caller is responsible to free the error message.
 730  */
 731 jzfile *
 732 ZIP_Open_Generic(const char *name, char **pmsg, int mode, jlong lastModified)
 733 {
 734     jzfile *zip = NULL;
 735 
 736     /* Clear zip error message */
 737     if (pmsg != 0) {
 738         *pmsg = NULL;
 739     }
 740 
 741     zip = ZIP_Get_From_Cache(name, pmsg, lastModified);
 742 
 743     if (zip == NULL && *pmsg == NULL) {
 744         ZFILE zfd = ZFILE_Open(name, mode);
 745         zip = ZIP_Put_In_Cache(name, zfd, pmsg, lastModified);
 746     }
 747     return zip;
 748 }
 749 
 750 /*
 751  * Returns the jzfile corresponding to the given file name from the cache of
 752  * zip files, or NULL if the file is not in the cache.  If the name is longer
 753  * than PATH_MAX or a zip error occurred then *pmsg will be set to the error
 754  * message text if pmsg != 0. Otherwise, *pmsg will be set to NULL. Caller
 755  * is responsible to free the error message.
 756  */
 757 jzfile *
 758 ZIP_Get_From_Cache(const char *name, char **pmsg, jlong lastModified)
 759 {
 760     char buf[PATH_MAX];
 761     jzfile *zip;
 762 
 763     if (InitializeZip()) {
 764         return NULL;
 765     }
 766 
 767     /* Clear zip error message */
 768     if (pmsg != 0) {
 769         *pmsg = NULL;
 770     }
 771 
 772     if (strlen(name) >= PATH_MAX) {
 773         if (pmsg) {
 774             *pmsg = strdup("zip file name too long");
 775         }
 776         return NULL;
 777     }
 778     strcpy(buf, name);
 779     JVM_NativePath(buf);
 780     name = buf;
 781 
 782     MLOCK(zfiles_lock);
 783     for (zip = zfiles; zip != NULL; zip = zip->next) {
 784         if (strcmp(name, zip->name) == 0
 785             && (zip->lastModified == lastModified || zip->lastModified == 0)
 786             && zip->refs < MAXREFS) {
 787             zip->refs++;
 788             break;
 789         }
 790     }
 791     MUNLOCK(zfiles_lock);
 792     return zip;
 793 }
 794 
 795 /*
 796  * Reads data from the given file descriptor to create a jzfile, puts the
 797  * jzfile in a cache, and returns that jzfile.  Returns NULL in case of error.
 798  * If a zip error occurs, then *pmsg will be set to the error message text if
 799  * pmsg != 0. Otherwise, *pmsg will be set to NULL. Caller is responsible to
 800  * free the error message.
 801  */
 802 
 803 jzfile *
 804 ZIP_Put_In_Cache(const char *name, ZFILE zfd, char **pmsg, jlong lastModified)
 805 {
 806     return ZIP_Put_In_Cache0(name, zfd, pmsg, lastModified, JNI_TRUE);
 807 }
 808 
 809 jzfile *
 810 ZIP_Put_In_Cache0(const char *name, ZFILE zfd, char **pmsg, jlong lastModified,
 811                  jboolean usemmap)
 812 {
 813     char errbuf[256];
 814     jlong len;
 815     jzfile *zip;
 816 
 817     if ((zip = allocZip(name)) == NULL) {
 818         return NULL;
 819     }
 820 
 821 #ifdef USE_MMAP
 822     zip->usemmap = usemmap;
 823 #endif
 824     zip->refs = 1;
 825     zip->lastModified = lastModified;
 826 
 827     if (zfd == -1) {
 828         if (pmsg && JVM_GetLastErrorString(errbuf, sizeof(errbuf)) > 0)
 829             *pmsg = strdup(errbuf);
 830         freeZip(zip);
 831         return NULL;
 832     }
 833 
 834     len = zip->len = IO_Lseek(zfd, 0, SEEK_END);
 835     if (len <= 0) {
 836         if (len == 0) { /* zip file is empty */
 837             if (pmsg) {
 838                 *pmsg = strdup("zip file is empty");
 839             }
 840         } else { /* error */
 841             if (pmsg && JVM_GetLastErrorString(errbuf, sizeof(errbuf)) > 0)
 842                 *pmsg = strdup(errbuf);
 843         }
 844         ZFILE_Close(zfd);
 845         freeZip(zip);
 846         return NULL;
 847     }
 848 
 849     zip->zfd = zfd;
 850     if (readCEN(zip, -1) < 0) {
 851         /* An error occurred while trying to read the zip file */
 852         if (pmsg != 0) {
 853             /* Set the zip error message */
 854             if (zip->msg != NULL)
 855                 *pmsg = strdup(zip->msg);
 856         }
 857         freeZip(zip);
 858         return NULL;
 859     }
 860     MLOCK(zfiles_lock);
 861     zip->next = zfiles;
 862     zfiles = zip;
 863     MUNLOCK(zfiles_lock);
 864 
 865     return zip;
 866 }
 867 
 868 /*
 869  * Opens a zip file for reading. Returns the jzfile object or NULL
 870  * if an error occurred. If a zip error occurred then *msg will be
 871  * set to the error message text if msg != 0. Otherwise, *msg will be
 872  * set to NULL. Caller doesn't need to free the error message.
 873  */
 874 jzfile * JNICALL
 875 ZIP_Open(const char *name, char **pmsg)
 876 {
 877     jzfile *file = ZIP_Open_Generic(name, pmsg, O_RDONLY, 0);
 878     if (file == NULL && pmsg != NULL && *pmsg != NULL) {
 879         free(*pmsg);
 880         *pmsg = "Zip file open error";
 881     }
 882     return file;
 883 }
 884 
 885 /*
 886  * Closes the specified zip file object.
 887  */
 888 void JNICALL
 889 ZIP_Close(jzfile *zip)
 890 {
 891     MLOCK(zfiles_lock);
 892     if (--zip->refs > 0) {
 893         /* Still more references so just return */
 894         MUNLOCK(zfiles_lock);
 895         return;
 896     }
 897     /* No other references so close the file and remove from list */
 898     if (zfiles == zip) {
 899         zfiles = zfiles->next;
 900     } else {
 901         jzfile *zp;
 902         for (zp = zfiles; zp->next != 0; zp = zp->next) {
 903             if (zp->next == zip) {
 904                 zp->next = zip->next;
 905                 break;
 906             }
 907         }
 908     }
 909     MUNLOCK(zfiles_lock);
 910     freeZip(zip);
 911     return;
 912 }
 913 
 914 /* Empirically, most CEN headers are smaller than this. */
 915 #define AMPLE_CEN_HEADER_SIZE 160
 916 
 917 /* A good buffer size when we want to read CEN headers sequentially. */
 918 #define CENCACHE_PAGESIZE 8192
 919 
 920 static char *
 921 readCENHeader(jzfile *zip, jlong cenpos, jint bufsize)
 922 {
 923     jint censize;
 924     ZFILE zfd = zip->zfd;
 925     char *cen;
 926     if (bufsize > zip->len - cenpos)
 927         bufsize = (jint)(zip->len - cenpos);
 928     if ((cen = malloc(bufsize)) == NULL)       goto Catch;
 929     if (readFullyAt(zfd, cen, bufsize, cenpos) == -1)     goto Catch;
 930     censize = CENSIZE(cen);
 931     if (censize <= bufsize) return cen;
 932     if ((cen = realloc(cen, censize)) == NULL)              goto Catch;
 933     if (readFully(zfd, cen+bufsize, censize-bufsize) == -1) goto Catch;
 934     return cen;
 935 
 936  Catch:
 937     free(cen);
 938     return NULL;
 939 }
 940 
 941 static char *
 942 sequentialAccessReadCENHeader(jzfile *zip, jlong cenpos)
 943 {
 944     cencache *cache = &zip->cencache;
 945     char *cen;
 946     if (cache->data != NULL
 947         && (cenpos >= cache->pos)
 948         && (cenpos + CENHDR <= cache->pos + CENCACHE_PAGESIZE))
 949     {
 950         cen = cache->data + cenpos - cache->pos;
 951         if (cenpos + CENSIZE(cen) <= cache->pos + CENCACHE_PAGESIZE)
 952             /* A cache hit */
 953             return cen;
 954     }
 955 
 956     if ((cen = readCENHeader(zip, cenpos, CENCACHE_PAGESIZE)) == NULL)
 957         return NULL;
 958     free(cache->data);
 959     cache->data = cen;
 960     cache->pos  = cenpos;
 961     return cen;
 962 }
 963 
 964 typedef enum { ACCESS_RANDOM, ACCESS_SEQUENTIAL } AccessHint;
 965 
 966 /*
 967  * Return a new initialized jzentry corresponding to a given hash cell.
 968  * In case of error, returns NULL.
 969  * We already sanity-checked all the CEN headers for ZIP format errors
 970  * in readCEN(), so we don't check them again here.
 971  * The ZIP lock should be held here.
 972  */
 973 static jzentry *
 974 newEntry(jzfile *zip, jzcell *zc, AccessHint accessHint)
 975 {
 976     jlong locoff;
 977     jint nlen, elen, clen;
 978     jzentry *ze;
 979     char *cen;
 980 
 981     if ((ze = (jzentry *) malloc(sizeof(jzentry))) == NULL) return NULL;
 982     ze->name    = NULL;
 983     ze->extra   = NULL;
 984     ze->comment = NULL;
 985 
 986 #ifdef USE_MMAP
 987     if (zip->usemmap) {
 988         cen = (char*) zip->maddr + zc->cenpos - zip->offset;
 989     } else
 990 #endif
 991     {
 992         if (accessHint == ACCESS_RANDOM)
 993             cen = readCENHeader(zip, zc->cenpos, AMPLE_CEN_HEADER_SIZE);
 994         else
 995             cen = sequentialAccessReadCENHeader(zip, zc->cenpos);
 996         if (cen == NULL) goto Catch;
 997     }
 998 
 999     nlen      = CENNAM(cen);
1000     elen      = CENEXT(cen);
1001     clen      = CENCOM(cen);
1002     ze->time  = CENTIM(cen);
1003     ze->size  = CENLEN(cen);
1004     ze->csize = (CENHOW(cen) == STORED) ? 0 : CENSIZ(cen);
1005     ze->crc   = CENCRC(cen);
1006     locoff    = CENOFF(cen);
1007     ze->pos   = -(zip->locpos + locoff);
1008     ze->flag  = CENFLG(cen);
1009 
1010     if ((ze->name = malloc(nlen + 1)) == NULL) goto Catch;
1011     memcpy(ze->name, cen + CENHDR, nlen);
1012     ze->name[nlen] = '\0';
1013     if (elen > 0) {
1014         char *extra = cen + CENHDR + nlen;
1015 
1016         /* This entry has "extra" data */
1017         if ((ze->extra = malloc(elen + 2)) == NULL) goto Catch;
1018         ze->extra[0] = (unsigned char) elen;
1019         ze->extra[1] = (unsigned char) (elen >> 8);
1020         memcpy(ze->extra+2, extra, elen);
1021         if (ze->csize == ZIP64_MAGICVAL || ze->size == ZIP64_MAGICVAL ||
1022             locoff == ZIP64_MAGICVAL) {
1023             jint off = 0;
1024             while ((off + 4) < elen) {    // spec: HeaderID+DataSize+Data
1025                 jint sz = SH(extra, off + 2);
1026                 if (SH(extra, off) == ZIP64_EXTID) {
1027                     off += 4;
1028                     if (ze->size == ZIP64_MAGICVAL) {
1029                         // if invalid zip64 extra fields, just skip
1030                         if (sz < 8 || (off + 8) > elen)
1031                             break;
1032                         ze->size = LL(extra, off);
1033                         sz -= 8;
1034                         off += 8;
1035                     }
1036                     if (ze->csize == ZIP64_MAGICVAL) {
1037                         if (sz < 8 || (off + 8) > elen)
1038                             break;
1039                         ze->csize = LL(extra, off);
1040                         sz -= 8;
1041                         off += 8;
1042                     }
1043                     if (locoff == ZIP64_MAGICVAL) {
1044                         if (sz < 8 || (off + 8) > elen)
1045                             break;
1046                         ze->pos = -(zip->locpos +  LL(extra, off));
1047                         sz -= 8;
1048                         off += 8;
1049                     }
1050                     break;
1051                 }
1052                 off += (sz + 4);
1053             }
1054         }
1055     }
1056 
1057     if (clen > 0) {
1058         /* This entry has a comment */
1059         if ((ze->comment = malloc(clen + 1)) == NULL) goto Catch;
1060         memcpy(ze->comment, cen + CENHDR + nlen + elen, clen);
1061         ze->comment[clen] = '\0';
1062     }
1063     goto Finally;
1064 
1065  Catch:
1066     free(ze->name);
1067     free(ze->extra);
1068     free(ze->comment);
1069     free(ze);
1070     ze = NULL;
1071 
1072  Finally:
1073 #ifdef USE_MMAP
1074     if (!zip->usemmap)
1075 #endif
1076         if (cen != NULL && accessHint == ACCESS_RANDOM) free(cen);
1077     return ze;
1078 }
1079 
1080 /*
1081  * Free the given jzentry.
1082  * In fact we maintain a one-entry cache of the most recently used
1083  * jzentry for each zip.  This optimizes a common access pattern.
1084  */
1085 
1086 void
1087 ZIP_FreeEntry(jzfile *jz, jzentry *ze)
1088 {
1089     jzentry *last;
1090     ZIP_Lock(jz);
1091     last = jz->cache;
1092     jz->cache = ze;
1093     ZIP_Unlock(jz);
1094     if (last != NULL) {
1095         /* Free the previously cached jzentry */
1096         free(last->name);
1097         if (last->extra)   free(last->extra);
1098         if (last->comment) free(last->comment);
1099         free(last);
1100     }
1101 }
1102 
1103 /*
1104  * Returns the zip entry corresponding to the specified name, or
1105  * NULL if not found.
1106  */
1107 jzentry *
1108 ZIP_GetEntry(jzfile *zip, char *name, jint ulen)
1109 {
1110     unsigned int hsh = hash(name);
1111     jint idx;
1112     jzentry *ze = 0;
1113 
1114     ZIP_Lock(zip);
1115     if (zip->total == 0) {
1116         goto Finally;
1117     }
1118 
1119     idx = zip->table[hsh % zip->tablelen];
1120 
1121     /*
1122      * This while loop is an optimization where a double lookup
1123      * for name and name+/ is being performed. The name char
1124      * array has enough room at the end to try again with a
1125      * slash appended if the first table lookup does not succeed.
1126      */
1127     while(1) {
1128 
1129         /* Check the cached entry first */
1130         ze = zip->cache;
1131         if (ze && strcmp(ze->name,name) == 0) {
1132             /* Cache hit!  Remove and return the cached entry. */
1133             zip->cache = 0;
1134             ZIP_Unlock(zip);
1135             return ze;
1136         }
1137         ze = 0;
1138 
1139         /*
1140          * Search down the target hash chain for a cell whose
1141          * 32 bit hash matches the hashed name.
1142          */
1143         while (idx != ZIP_ENDCHAIN) {
1144             jzcell *zc = &zip->entries[idx];
1145 
1146             if (zc->hash == hsh) {
1147                 /*
1148                  * OK, we've found a ZIP entry whose 32 bit hashcode
1149                  * matches the name we're looking for.  Try to read
1150                  * its entry information from the CEN.  If the CEN
1151                  * name matches the name we're looking for, we're
1152                  * done.
1153                  * If the names don't match (which should be very rare)
1154                  * we keep searching.
1155                  */
1156                 ze = newEntry(zip, zc, ACCESS_RANDOM);
1157                 if (ze && strcmp(ze->name, name)==0) {
1158                     break;
1159                 }
1160                 if (ze != 0) {
1161                     /* We need to release the lock across the free call */
1162                     ZIP_Unlock(zip);
1163                     ZIP_FreeEntry(zip, ze);
1164                     ZIP_Lock(zip);
1165                 }
1166                 ze = 0;
1167             }
1168             idx = zc->next;
1169         }
1170 
1171         /* Entry found, return it */
1172         if (ze != 0) {
1173             break;
1174         }
1175 
1176         /* If no real length was passed in, we are done */
1177         if (ulen == 0) {
1178             break;
1179         }
1180 
1181         /* Slash is already there? */
1182         if (name[ulen-1] == '/') {
1183             break;
1184         }
1185 
1186         /* Add slash and try once more */
1187         name[ulen] = '/';
1188         name[ulen+1] = '\0';
1189         hsh = hash_append(hsh, '/');
1190         idx = zip->table[hsh % zip->tablelen];
1191         ulen = 0;
1192     }
1193 
1194 Finally:
1195     ZIP_Unlock(zip);
1196     return ze;
1197 }
1198 
1199 /*
1200  * Returns the n'th (starting at zero) zip file entry, or NULL if the
1201  * specified index was out of range.
1202  */
1203 jzentry * JNICALL
1204 ZIP_GetNextEntry(jzfile *zip, jint n)
1205 {
1206     jzentry *result;
1207     if (n < 0 || n >= zip->total) {
1208         return 0;
1209     }
1210     ZIP_Lock(zip);
1211     result = newEntry(zip, &zip->entries[n], ACCESS_SEQUENTIAL);
1212     ZIP_Unlock(zip);
1213     return result;
1214 }
1215 
1216 /*
1217  * Locks the specified zip file for reading.
1218  */
1219 void
1220 ZIP_Lock(jzfile *zip)
1221 {
1222     MLOCK(zip->lock);
1223 }
1224 
1225 /*
1226  * Unlocks the specified zip file.
1227  */
1228 void
1229 ZIP_Unlock(jzfile *zip)
1230 {
1231     MUNLOCK(zip->lock);
1232 }
1233 
1234 /*
1235  * Returns the offset of the entry data within the zip file.
1236  * Returns -1 if an error occurred, in which case zip->msg will
1237  * contain the error text.
1238  */
1239 jlong
1240 ZIP_GetEntryDataOffset(jzfile *zip, jzentry *entry)
1241 {
1242     /* The Zip file spec explicitly allows the LOC extra data size to
1243      * be different from the CEN extra data size, although the JDK
1244      * never creates such zip files.  Since we cannot trust the CEN
1245      * extra data size, we need to read the LOC to determine the entry
1246      * data offset.  We do this lazily to avoid touching the virtual
1247      * memory page containing the LOC when initializing jzentry
1248      * objects.  (This speeds up javac by a factor of 10 when the JDK
1249      * is installed on a very slow filesystem.)
1250      */
1251     if (entry->pos <= 0) {
1252         unsigned char loc[LOCHDR];
1253         if (readFullyAt(zip->zfd, loc, LOCHDR, -(entry->pos)) == -1) {
1254             zip->msg = "error reading zip file";
1255             return -1;
1256         }
1257         if (GETSIG(loc) != LOCSIG) {
1258             zip->msg = "invalid LOC header (bad signature)";
1259             return -1;
1260         }
1261         entry->pos = (- entry->pos) + LOCHDR + LOCNAM(loc) + LOCEXT(loc);
1262     }
1263     return entry->pos;
1264 }
1265 
1266 /*
1267  * Reads bytes from the specified zip entry. Assumes that the zip
1268  * file had been previously locked with ZIP_Lock(). Returns the
1269  * number of bytes read, or -1 if an error occurred. If zip->msg != 0
1270  * then a zip error occurred and zip->msg contains the error text.
1271  *
1272  * The current implementation does not support reading an entry that
1273  * has the size bigger than 2**32 bytes in ONE invocation.
1274  */
1275 jint
1276 ZIP_Read(jzfile *zip, jzentry *entry, jlong pos, void *buf, jint len)
1277 {
1278     jlong entry_size = (entry->csize != 0) ? entry->csize : entry->size;
1279     jlong start;
1280 
1281     /* Clear previous zip error */
1282     zip->msg = NULL;
1283 
1284     /* Check specified position */
1285     if (pos < 0 || pos > entry_size - 1) {
1286         zip->msg = "ZIP_Read: specified offset out of range";
1287         return -1;
1288     }
1289 
1290     /* Check specified length */
1291     if (len <= 0)
1292         return 0;
1293     if (len > entry_size - pos)
1294         len = (jint)(entry_size - pos);
1295 
1296     /* Get file offset to start reading data */
1297     start = ZIP_GetEntryDataOffset(zip, entry);
1298     if (start < 0)
1299         return -1;
1300     start += pos;
1301 
1302     if (start + len > zip->len) {
1303         zip->msg = "ZIP_Read: corrupt zip file: invalid entry size";
1304         return -1;
1305     }
1306 
1307     if (readFullyAt(zip->zfd, buf, len, start) == -1) {
1308         zip->msg = "ZIP_Read: error reading zip file";
1309         return -1;
1310     }
1311     return len;
1312 }
1313 
1314 
1315 /* The maximum size of a stack-allocated buffer.
1316  */
1317 #define BUF_SIZE 4096
1318 
1319 /*
1320  * This function is used by the runtime system to load compressed entries
1321  * from ZIP/JAR files specified in the class path. It is defined here
1322  * so that it can be dynamically loaded by the runtime if the zip library
1323  * is found.
1324  *
1325  * The current implementation does not support reading an entry that
1326  * has the size bigger than 2**32 bytes in ONE invocation.
1327  */
1328 jboolean
1329 InflateFully(jzfile *zip, jzentry *entry, void *buf, char **msg)
1330 {
1331     z_stream strm;
1332     char tmp[BUF_SIZE];
1333     jlong pos = 0;
1334     jlong count = entry->csize;
1335 
1336     *msg = 0; /* Reset error message */
1337 
1338     if (count == 0) {
1339         *msg = "inflateFully: entry not compressed";
1340         return JNI_FALSE;
1341     }
1342 
1343     memset(&strm, 0, sizeof(z_stream));
1344     if (inflateInit2(&strm, -MAX_WBITS) != Z_OK) {
1345         *msg = strm.msg;
1346         return JNI_FALSE;
1347     }
1348 
1349     strm.next_out = buf;
1350     strm.avail_out = (uInt)entry->size;
1351 
1352     while (count > 0) {
1353         jint n = count > (jlong)sizeof(tmp) ? (jint)sizeof(tmp) : (jint)count;
1354         ZIP_Lock(zip);
1355         n = ZIP_Read(zip, entry, pos, tmp, n);
1356         ZIP_Unlock(zip);
1357         if (n <= 0) {
1358             if (n == 0) {
1359                 *msg = "inflateFully: Unexpected end of file";
1360             }
1361             inflateEnd(&strm);
1362             return JNI_FALSE;
1363         }
1364         pos += n;
1365         count -= n;
1366         strm.next_in = (Bytef *)tmp;
1367         strm.avail_in = n;
1368         do {
1369             switch (inflate(&strm, Z_PARTIAL_FLUSH)) {
1370             case Z_OK:
1371                 break;
1372             case Z_STREAM_END:
1373                 if (count != 0 || strm.total_out != entry->size) {
1374                     *msg = "inflateFully: Unexpected end of stream";
1375                     inflateEnd(&strm);
1376                     return JNI_FALSE;
1377                 }
1378                 break;
1379             default:
1380                 break;
1381             }
1382         } while (strm.avail_in > 0);
1383     }
1384     inflateEnd(&strm);
1385     return JNI_TRUE;
1386 }
1387 
1388 /*
1389  * The current implementation does not support reading an entry that
1390  * has the size bigger than 2**32 bytes in ONE invocation.
1391  */
1392 jzentry * JNICALL
1393 ZIP_FindEntry(jzfile *zip, char *name, jint *sizeP, jint *nameLenP)
1394 {
1395     jzentry *entry = ZIP_GetEntry(zip, name, 0);
1396     if (entry) {
1397         *sizeP = (jint)entry->size;
1398         *nameLenP = strlen(entry->name);
1399     }
1400     return entry;
1401 }
1402 
1403 /*
1404  * Reads a zip file entry into the specified byte array
1405  * When the method completes, it releases the jzentry.
1406  * Note: this is called from the separately delivered VM (hotspot/classic)
1407  * so we have to be careful to maintain the expected behaviour.
1408  */
1409 jboolean JNICALL
1410 ZIP_ReadEntry(jzfile *zip, jzentry *entry, unsigned char *buf, char *entryname)
1411 {
1412     char *msg;
1413 
1414     strcpy(entryname, entry->name);
1415     if (entry->csize == 0) {
1416         /* Entry is stored */
1417         jlong pos = 0;
1418         jlong size = entry->size;
1419         while (pos < size) {
1420             jint n;
1421             jlong limit = ((((jlong) 1) << 31) - 1);
1422             jint count = (size - pos < limit) ?
1423                 /* These casts suppress a VC++ Internal Compiler Error */
1424                 (jint) (size - pos) :
1425                 (jint) limit;
1426             ZIP_Lock(zip);
1427             n = ZIP_Read(zip, entry, pos, buf, count);
1428             msg = zip->msg;
1429             ZIP_Unlock(zip);
1430             if (n == -1) {
1431                 jio_fprintf(stderr, "%s: %s\n", zip->name,
1432                             msg != 0 ? msg : strerror(errno));
1433                 return JNI_FALSE;
1434             }
1435             buf += n;
1436             pos += n;
1437         }
1438     } else {
1439         /* Entry is compressed */
1440         int ok = InflateFully(zip, entry, buf, &msg);
1441         if (!ok) {
1442             if ((msg == NULL) || (*msg == 0)) {
1443                 msg = zip->msg;
1444             }
1445             jio_fprintf(stderr, "%s: %s\n", zip->name,
1446                         msg != 0 ? msg : strerror(errno));
1447             return JNI_FALSE;
1448         }
1449     }
1450 
1451     ZIP_FreeEntry(zip, entry);
1452 
1453     return JNI_TRUE;
1454 }