/home/daniel/Projects/java/jdk/src/java.base/share/native/libzip/zip

Bug Summary

File:	jdk/src/java.base/share/native/libzip/zip_util.c
Warning:	line 760, column 12 Potential leak of memory pointed to by 'cenbuf'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -triple x86_64-pc-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name zip_util.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mthread-model posix -fno-delete-null-pointer-checks -mframe-pointer=all -relaxed-aliasing -fmath-errno -fno-rounding-math -masm-verbose -mconstructor-aliases -munwind-tables -target-cpu x86-64 -dwarf-column-info -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib/llvm-10/lib/clang/10.0.0 -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/modules_include/java.base/linux -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libjava -I /home/daniel/Projects/java/jdk/src/java.base/unix/native/libjava -I /home/daniel/Projects/java/jdk/src/hotspot/share/include -I /home/daniel/Projects/java/jdk/src/hotspot/os/posix/include -D LIBC=gnu -D _GNU_SOURCE -D _REENTRANT -D _LARGEFILE64_SOURCE -D LINUX -D DEBUG -D _LITTLE_ENDIAN -D ARCH="amd64" -D amd64 -D _LP64=1 -I /home/daniel/Projects/java/jdk/src/java.base/share/native/libzip -I /home/daniel/Projects/java/jdk/build/linux-x86_64-server-fastdebug/support/headers/java.base -D USE_MMAP -U DEBUG -D _FORTIFY_SOURCE=2 -internal-isystem /usr/local/include -internal-isystem /usr/lib/llvm-10/lib/clang/10.0.0/include -internal-externc-isystem /usr/include/x86_64-linux-gnu -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wno-unused -Wno-unused-function -Wno-implicit-fallthrough -std=c99 -fdebug-compilation-dir /home/daniel/Projects/java/jdk/make -ferror-limit 19 -fmessage-length 0 -fvisibility hidden -stack-protector 1 -fgnuc-version=4.2.1 -fobjc-runtime=gcc -fdiagnostics-show-option -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -o /home/daniel/Projects/java/scan/2021-12-21-193737-8510-1 -x c /home/daniel/Projects/java/jdk/src/java.base/share/native/libzip/zip_util.c
1/*
* Copyright (c) 1995, 2020, Oracle and/or its affiliates. All rights reserved.
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* This code is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License version 2 only, as
* published by the Free Software Foundation.  Oracle designates this
* particular file as subject to the "Classpath" exception as provided
* by Oracle in the LICENSE file that accompanied this code.
*
* This code is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
* version 2 for more details (a copy is included in the LICENSE file that
* accompanied this code).
*
* You should have received a copy of the GNU General Public License version
* 2 along with this work; if not, write to the Free Software Foundation,
* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
*
* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
* or visit www.oracle.com if you need additional information or have any
* questions.
*/

26/*
* Support for reading ZIP/JAR files.
*/

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>

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>

49#ifdef _ALLBSD_SOURCE
50#define off64_t off_t
51#define mmap64 mmap
52#endif

54/* USE_MMAP means mmap the CEN & ENDHDR part of the zip file. */
55#ifdef USE_MMAP1
56#include <sys/mman.h>
57#endif

59#define MAXREFS0xFFFF 0xFFFF  /* max number of open zip file references */

61#define MCREATE()JVM_RawMonitorCreate()      JVM_RawMonitorCreate()
62#define MLOCK(lock)JVM_RawMonitorEnter(lock)    JVM_RawMonitorEnter(lock)
63#define MUNLOCK(lock)JVM_RawMonitorExit(lock)  JVM_RawMonitorExit(lock)
64#define MDESTROY(lock)JVM_RawMonitorDestroy(lock) JVM_RawMonitorDestroy(lock)

66#define CENSIZE(cen)(46 + ((((unsigned char *)(cen))[28]) | ((((unsigned char *)(
cen))[28 +1]) << 8)) + ((((unsigned char *)(cen))[30]) |
 ((((unsigned char *)(cen))[30 +1]) << 8)) + ((((unsigned
 char *)(cen))[32]) | ((((unsigned char *)(cen))[32 +1]) <<
 8))) (CENHDR46 + CENNAM(cen)((((unsigned char *)(cen))[28]) | ((((unsigned char *)(cen))[
+1]) << 8)) + CENEXT(cen)((((unsigned char *)(cen))[30]) | ((((unsigned char *)(cen))[
+1]) << 8)) + CENCOM(cen)((((unsigned char *)(cen))[32]) | ((((unsigned char *)(cen))[
+1]) << 8)))

68static jzfile *zfiles = 0;      /* currently open zip files */
69static void *zfiles_lock = 0;

71static void freeCEN(jzfile *);

73#ifndef PATH_MAX4096
74#define PATH_MAX4096 1024
75#endif

77static jint INITIAL_META_COUNT = 2;   /* initial number of entries in meta name array */

79/*
* Declare library specific JNI_Onload entry if static build
*/
82#ifdef STATIC_BUILD
83DEF_STATIC_JNI_OnLoad
84#endif

86/*
* The ZFILE_* functions exist to provide some platform-independence with
* respect to file access needs.
*/

91/*
* Opens the named file for reading, returning a ZFILE.
*
* Compare this with winFileHandleOpen in windows/native/java/io/io_util_md.c.
* This function does not take JNIEnv* and uses CreateFile (instead of
* CreateFileW).  The expectation is that this function will be called only
* from ZIP_Open_Generic, which in turn is used by the JVM, where we do not
* need to concern ourselves with wide chars.
*/
100static ZFILEint
101ZFILE_Open(const char *fname, int flags) {
102#ifdef WIN32
  WCHAR *wfname, *wprefixed_fname;
  size_t fname_length;
  jlong fhandle;
  const DWORD access =
      (flags & O_RDWR02)   ? (GENERIC_WRITE | GENERIC_READ) :
      (flags & O_WRONLY01) ?  GENERIC_WRITE :
      GENERIC_READ;
  const DWORD sharing =
      FILE_SHARE_READ | FILE_SHARE_WRITE;
  const DWORD disposition =
      /* Note: O_TRUNC overrides O_CREAT */
      (flags & O_TRUNC01000) ? CREATE_ALWAYS :
      (flags & O_CREAT0100) ? OPEN_ALWAYS   :
      OPEN_EXISTING;
  const DWORD  maybeWriteThrough =
      (flags & (O_SYNC04010000 | O_DSYNC010000)) ?
      FILE_FLAG_WRITE_THROUGH :
      FILE_ATTRIBUTE_NORMAL;
  const DWORD maybeDeleteOnClose =
      (flags & O_TEMPORARY) ?
      FILE_FLAG_DELETE_ON_CLOSE :
      FILE_ATTRIBUTE_NORMAL;
  const DWORD flagsAndAttributes = maybeWriteThrough | maybeDeleteOnClose;

  fname_length = strlen(fname);
  if (fname_length < MAX_PATH) {
      return (jlong)CreateFile(
          fname,              /* path name in multibyte char */
          access,             /* Read and/or write permission */
          sharing,            /* File sharing flags */
          NULL((void*)0),               /* Security attributes */
          disposition,        /* creation disposition */
          flagsAndAttributes, /* flags and attributes */
          NULL((void*)0));
  } else {
      /* Get required buffer size to convert to Unicode */
      int wfname_len = MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS,
                                           fname, -1, NULL((void*)0), 0);
      if (wfname_len == 0) {
          return (jlong)INVALID_HANDLE_VALUE;
      }
      if ((wfname = (WCHAR*)malloc(wfname_len * sizeof(WCHAR))) == NULL((void*)0)) {
          return (jlong)INVALID_HANDLE_VALUE;
      }
      if (MultiByteToWideChar(CP_ACP, MB_ERR_INVALID_CHARS,
                              fname, -1, wfname, wfname_len) == 0) {
          free(wfname);
          return (jlong)INVALID_HANDLE_VALUE;
      }
      wprefixed_fname = getPrefixed(wfname, (int)fname_length);
      fhandle = (jlong)CreateFileW(
          wprefixed_fname,    /* Wide char path name */
          access,             /* Read and/or write permission */
          sharing,            /* File sharing flags */
          NULL((void*)0),               /* Security attributes */
          disposition,        /* creation disposition */
          flagsAndAttributes, /* flags and attributes */
          NULL((void*)0));
      free(wfname);
      free(wprefixed_fname);
      return fhandle;
  }
165#else
  return open(fname, flags, 0);
167#endif
168}

170/*
* The io_util_md.h files do not provide IO_CLOSE, hence we use platform
* specifics.
*/
174static void
175ZFILE_Close(ZFILEint zfd) {
176#ifdef WIN32
  CloseHandle((HANDLE) zfd);
178#else
  close(zfd);
180#endif
181}

183static int
184ZFILE_read(ZFILEint zfd, char *buf, jint nbytes) {
185#ifdef WIN32
  return (int) IO_ReadhandleRead(zfd, buf, nbytes);
187#else
  return read(zfd, buf, nbytes);
189#endif
190}

192/*
* Initialize zip file support. Return 0 if successful otherwise -1
* if could not be initialized.
*/
196static jint
197InitializeZip()
198{
  static jboolean inited = JNI_FALSE0;

  // Initialize errno to 0.  It may be set later (e.g. during memory
  // allocation) but we can disregard previous values.
  errno(*__errno_location ()) = 0;

  if (inited)
      return 0;
  zfiles_lock = MCREATE()JVM_RawMonitorCreate();
  if (zfiles_lock == 0) {
      return -1;
  }
  inited = JNI_TRUE1;

  return 0;
214}

216/*
* Reads len bytes of data into buf.
* Returns 0 if all bytes could be read, otherwise returns -1.
*/
220static int
221readFully(ZFILEint zfd, void *buf, jlong len) {
char *bp = (char *) buf;

while (len > 0) {
      jlong limit = ((((jlong) 1) << 31) - 1);
      jint count = (len < limit) ?
          (jint) len :
          (jint) limit;
      jint n = ZFILE_read(zfd, bp, count);
      if (n > 0) {
          bp += n;
          len -= n;
      } else if (n == -1 && errno(*__errno_location ()) == EINTR4) {
        /* Retry after EINTR (interrupted by signal). */
          continue;
      } else { /* EOF or IO error */
          return -1;
      }
  }
  return 0;
241}

243/*
* Reads len bytes of data from the specified offset into buf.
* Returns 0 if all bytes could be read, otherwise returns -1.
*/
247static int
248readFullyAt(ZFILEint zfd, void *buf, jlong len, jlong offset)
249{
  if (IO_Lseeklseek64(zfd, offset, SEEK_SET0) == -1) {
      return -1; /* lseek failure. */
  }

  return readFully(zfd, buf, len);
255}

257/*
* Allocates a new zip file object for the specified file name.
* Returns the zip file object or NULL if not enough memory.
*/
261static jzfile *
262allocZip(const char *name)
263{
  jzfile *zip;
  if (((zip = calloc(1, sizeof(jzfile))) != NULL((void*)0)) &&
      ((zip->name = strdup(name))        != NULL((void*)0)) &&
      ((zip->lock = MCREATE()JVM_RawMonitorCreate())           != NULL((void*)0))) {
      zip->zfd = -1;
      return zip;
  }

  if (zip != NULL((void*)0)) {
      free(zip->name);
      free(zip);
  }
  return NULL((void*)0);
277}

279/*
* Frees all native resources owned by the specified zip file object.
*/
282static void
283freeZip(jzfile *zip)
284{
  /* First free any cached jzentry */
  ZIP_FreeEntry(zip,0);
  if (zip->lock != NULL((void*)0)) MDESTROY(zip->lock)JVM_RawMonitorDestroy(zip->lock);
  free(zip->name);
  freeCEN(zip);

291#ifdef USE_MMAP1
  if (zip->usemmap) {
      if (zip->maddr != NULL((void*)0))
          munmap((char *)zip->maddr, zip->mlen);
  } else
296#endif
  {
      free(zip->cencache.data);
  }
  if (zip->comment != NULL((void*)0))
      free(zip->comment);
  if (zip->zfd != -1) ZFILE_Close(zip->zfd);
  free(zip);
304}

306/* The END header is followed by a variable length comment of size < 64k. */
307static const jlong END_MAXLEN = 0xFFFF + ENDHDR22;

309#define READBLOCKSZ128 128

311static jboolean verifyEND(jzfile *zip, jlong endpos, char *endbuf) {
  /* ENDSIG matched, however the size of file comment in it does not
     match the real size. One "common" cause for this problem is some
     "extra" bytes are padded at the end of the zipfile.
     Let's do some extra verification, we don't care about the performance
     in this situation.
   */
  jlong cenpos = endpos - ENDSIZ(endbuf)((((((unsigned char *)(endbuf))[12]) | ((((unsigned char *)(endbuf
))[12 +1]) << 8)) | (((((unsigned char *)(endbuf))[12 +
2]) | ((((unsigned char *)(endbuf))[12 +2 +1]) << 8)) <<
 16)) &0xffffffffUL);
  jlong locpos = cenpos - ENDOFF(endbuf)((((((unsigned char *)(endbuf))[16]) | ((((unsigned char *)(endbuf
))[16 +1]) << 8)) | (((((unsigned char *)(endbuf))[16 +
2]) | ((((unsigned char *)(endbuf))[16 +2 +1]) << 8)) <<
 16)) &0xffffffffUL);
  char buf[4];
  return (cenpos >= 0 &&
          locpos >= 0 &&
          readFullyAt(zip->zfd, buf, sizeof(buf), cenpos) != -1 &&
          CENSIG_AT(buf)(((buf)[0] == 'P') & ((buf)[1] == 'K') & ((buf)[2] ==
 1) & ((buf)[3] == 2)) &&
          readFullyAt(zip->zfd, buf, sizeof(buf), locpos) != -1 &&
          LOCSIG_AT(buf)(((buf)[0] == 'P') & ((buf)[1] == 'K') & ((buf)[2] ==
 3) & ((buf)[3] == 4)));
327}

329/*
* Searches for end of central directory (END) header. The contents of
* the END header will be read and placed in endbuf. Returns the file
* position of the END header, otherwise returns -1 if the END header
* was not found or an error occurred.
*/
335static jlong
336findEND(jzfile *zip, void *endbuf)
337{
  char buf[READBLOCKSZ128];
  jlong pos;
  const jlong len = zip->len;
  const ZFILEint zfd = zip->zfd;
  const jlong minHDR = len - END_MAXLEN > 0 ? len - END_MAXLEN : 0;
  const jlong minPos = minHDR - (sizeof(buf)-ENDHDR22);
  jint clen;

  for (pos = len - sizeof(buf); pos >= minPos; pos -= (sizeof(buf)-ENDHDR22)) {

      int i;
      jlong off = 0;
      if (pos < 0) {
          /* Pretend there are some NUL bytes before start of file */
          off = -pos;
          memset(buf, '\0', (size_t)off);
      }

      if (readFullyAt(zfd, buf + off, sizeof(buf) - off,
                      pos + off) == -1) {
          return -1;  /* System error */
      }

      /* Now scan the block backwards for END header signature */
      for (i = sizeof(buf) - ENDHDR22; i >= 0; i--) {
          if (buf[i+0] == 'P'    &&
              buf[i+1] == 'K'    &&
              buf[i+2] == '\005' &&
              buf[i+3] == '\006' &&
              ((pos + i + ENDHDR22 + ENDCOM(buf + i)((((unsigned char *)(buf + i))[20]) | ((((unsigned char *)(buf
 + i))[20 +1]) << 8)) == len)
               || verifyEND(zip, pos + i, buf + i))) {
              /* Found END header */
              memcpy(endbuf, buf + i, ENDHDR22);

              clen = ENDCOM(endbuf)((((unsigned char *)(endbuf))[20]) | ((((unsigned char *)(endbuf
))[20 +1]) << 8));
              if (clen != 0) {
                  zip->comment = malloc(clen + 1);
                  if (zip->comment == NULL((void*)0)) {
                      return -1;
                  }
                  if (readFullyAt(zfd, zip->comment, clen, pos + i + ENDHDR22)
                      == -1) {
                      free(zip->comment);
                      zip->comment = NULL((void*)0);
                      return -1;
                  }
                  zip->comment[clen] = '\0';
                  zip->clen = clen;
              }
              return pos + i;
          }
      }
  }

  return -1; /* END header not found */
393}

395/*
* Searches for the ZIP64 end of central directory (END) header. The
* contents of the ZIP64 END header will be read and placed in end64buf.
* Returns the file position of the ZIP64 END header, otherwise returns
* -1 if the END header was not found or an error occurred.
*
* The ZIP format specifies the "position" of each related record as
*   ...
*   [central directory]
*   [zip64 end of central directory record]
*   [zip64 end of central directory locator]
*   [end of central directory record]
*
* The offset of zip64 end locator can be calculated from endpos as
* "endpos - ZIP64_LOCHDR".
* The "offset" of zip64 end record is stored in zip64 end locator.
*/
412static jlong
413findEND64(jzfile *zip, void *end64buf, jlong endpos)
414{
  char loc64[ZIP64_LOCHDR20];
  jlong end64pos;
  if (readFullyAt(zip->zfd, loc64, ZIP64_LOCHDR20, endpos - ZIP64_LOCHDR20) == -1) {
      return -1;    // end64 locator not found
  }
  end64pos = ZIP64_LOCOFF(loc64)(((jlong)((((((unsigned char *)(loc64))[8]) | ((((unsigned char
 *)(loc64))[8 +1]) << 8)) | (((((unsigned char *)(loc64
))[8 +2]) | ((((unsigned char *)(loc64))[8 +2 +1]) << 8
)) << 16)) &0xffffffffUL)) | (((jlong)((((((unsigned
 char *)(loc64))[8 +4]) | ((((unsigned char *)(loc64))[8 +4 +
1]) << 8)) | (((((unsigned char *)(loc64))[8 +4 +2]) | (
(((unsigned char *)(loc64))[8 +4 +2 +1]) << 8)) <<
 16)) &0xffffffffUL)) << 32));
  if (readFullyAt(zip->zfd, end64buf, ZIP64_ENDHDR56, end64pos) == -1) {
      return -1;    // end64 record not found
  }
  return end64pos;
425}

427/*
* Returns a hash code value for a C-style NUL-terminated string.
*/
430static unsigned int
431hash(const char *s)
432{
  int h = 0;
  while (*s != '\0')
      h = 31*h + *s++;
  return h;
437}

439/*
* Returns a hash code value for a string of a specified length.
*/
442static unsigned int
443hashN(const char *s, int length)
444{
  int h = 0;
  while (length-- > 0)
      h = 31*h + *s++;
  return h;
449}

451static unsigned int
452hash_append(unsigned int hash, char c)
453{
  return ((int)hash)*31 + c;
455}

457/*
* Returns true if the specified entry's name begins with the string
* "META-INF/" irrespective of case.
*/
461static int
462isMetaName(const char *name, int length)
463{
  const char *s;
  if (length < (int)sizeof("META-INF/") - 1)
      return 0;
  for (s = "META-INF/"; *s != '\0'; s++) {
      char c = *name++;
      // Avoid toupper; it's locale-dependent
      if (c >= 'a' && c <= 'z') c += 'A' - 'a';
      if (*s != c)
          return 0;
  }
  return 1;
475}

477/*
* Increases the capacity of zip->metanames.
* Returns non-zero in case of allocation error.
*/
481static int
482growMetaNames(jzfile *zip)
483{
  jint i;
  /* double the meta names array */
  const jint new_metacount = zip->metacount << 1;
  zip->metanames =
      realloc(zip->metanames, new_metacount * sizeof(zip->metanames[0]));
  if (zip->metanames == NULL((void*)0)) return -1;
  for (i = zip->metacount; i < new_metacount; i++)
      zip->metanames[i] = NULL((void*)0);
  zip->metacurrent = zip->metacount;
  zip->metacount = new_metacount;
  return 0;
495}

497/*
* Adds name to zip->metanames.
* Returns non-zero in case of allocation error.
*/
501static int
502addMetaName(jzfile *zip, const char *name, int length)
503{
  jint i;
  if (zip->metanames == NULL((void*)0)) {
    zip->metacount = INITIAL_META_COUNT;
    zip->metanames = calloc(zip->metacount, sizeof(zip->metanames[0]));
    if (zip->metanames == NULL((void*)0)) return -1;
    zip->metacurrent = 0;
  }

  i = zip->metacurrent;

  /* current meta name array isn't full yet. */
  if (i < zip->metacount) {
    zip->metanames[i] = (char *) malloc(length+1);
    if (zip->metanames[i] == NULL((void*)0)) return -1;
    memcpy(zip->metanames[i], name, length);
    zip->metanames[i][length] = '\0';
    zip->metacurrent++;
    return 0;
  }

  /* No free entries in zip->metanames? */
  if (growMetaNames(zip) != 0) return -1;
  return addMetaName(zip, name, length);
527}

529static void
530freeMetaNames(jzfile *zip)
531{
  if (zip->metanames) {
      jint i;
      for (i = 0; i < zip->metacount; i++)
          free(zip->metanames[i]);
      free(zip->metanames);
      zip->metanames = NULL((void*)0);
  }
539}

541/* Free Zip data allocated by readCEN() */
542static void
543freeCEN(jzfile *zip)
544{
  free(zip->entries); zip->entries = NULL((void*)0);
  free(zip->table);   zip->table   = NULL((void*)0);
  freeMetaNames(zip);
548}

550/*
* Counts the number of CEN headers in a central directory extending
* from BEG to END.  Might return a bogus answer if the zip file is
* corrupt, but will not crash.
*/
555static jint
556countCENHeaders(unsigned char *beg, unsigned char *end)
557{
  jint count = 0;
  ptrdiff_t i;
  for (i = 0; i + CENHDR46 <= end - beg; i += CENSIZE(beg + i)(46 + ((((unsigned char *)(beg + i))[28]) | ((((unsigned char
 *)(beg + i))[28 +1]) << 8)) + ((((unsigned char *)(beg
 + i))[30]) | ((((unsigned char *)(beg + i))[30 +1]) <<
 8)) + ((((unsigned char *)(beg + i))[32]) | ((((unsigned char
 *)(beg + i))[32 +1]) << 8))))
      count++;
  return count;
563}

565#define ZIP_FORMAT_ERROR(message)if (1) { zip->msg = message; goto Catch; } else ((void)0) \
566if (1) { zip->msg = message; goto Catch; } else ((void)0)

568/*
* Reads zip file central directory. Returns the file position of first
* CEN header, otherwise returns -1 if an error occurred. If zip->msg != NULL
* then the error was a zip format error and zip->msg has the error text.
* Always pass in -1 for knownTotal; it's used for a recursive call.
*/
574static jlong
575readCEN(jzfile *zip, jint knownTotal)
576{
  /* Following are unsigned 32-bit */
  jlong endpos, end64pos, cenpos, cenlen, cenoff;
  /* Following are unsigned 16-bit */
  jint total, tablelen, i, j;
  unsigned char *cenbuf = NULL((void*)0);
  unsigned char *cenend;
  unsigned char *cp;
584#ifdef USE_MMAP1
  static jlong pagesize;
  jlong offset;
587#endif
  unsigned char endbuf[ENDHDR22];
  jint endhdrlen = ENDHDR22;
  jzcell *entries;
  jint *table;

  /* Clear previous zip error */
  zip->msg = NULL((void*)0);
  /* Get position of END header */
  if ((endpos = findEND(zip, endbuf)) == -1)
15
←
Taking false branch→
      return -1; /* no END header or system error */

  if (endpos == 0) return 0;  /* only END header present */
16
←
Assuming 'endpos' is not equal to 0→
17
←
Taking false branch→

  freeCEN(zip);
 /* Get position and length of central directory */
  cenlen = ENDSIZ(endbuf)((((((unsigned char *)(endbuf))[12]) | ((((unsigned char *)(endbuf
))[12 +1]) << 8)) | (((((unsigned char *)(endbuf))[12 +
2]) | ((((unsigned char *)(endbuf))[12 +2 +1]) << 8)) <<
 16)) &0xffffffffUL);
  cenoff = ENDOFF(endbuf)((((((unsigned char *)(endbuf))[16]) | ((((unsigned char *)(endbuf
))[16 +1]) << 8)) | (((((unsigned char *)(endbuf))[16 +
2]) | ((((unsigned char *)(endbuf))[16 +2 +1]) << 8)) <<
 16)) &0xffffffffUL);
  total  = ENDTOT(endbuf)((((unsigned char *)(endbuf))[10]) | ((((unsigned char *)(endbuf
))[10 +1]) << 8));
  if (cenlen == ZIP64_MAGICVAL0xffffffffLL || cenoff == ZIP64_MAGICVAL0xffffffffLL ||
18
←
Assuming 'cenlen' is not equal to ZIP64_MAGICVAL→
19
←
Assuming 'cenoff' is not equal to ZIP64_MAGICVAL→
21
←
Taking false branch→
      total == ZIP64_MAGICCOUNT0xffff) {
20
←
Assuming 'total' is not equal to ZIP64_MAGICCOUNT→
      unsigned char end64buf[ZIP64_ENDHDR56];
      if ((end64pos = findEND64(zip, end64buf, endpos)) != -1) {
          cenlen = ZIP64_ENDSIZ(end64buf)(((jlong)((((((unsigned char *)(end64buf))[40]) | ((((unsigned
 char *)(end64buf))[40 +1]) << 8)) | (((((unsigned char
 *)(end64buf))[40 +2]) | ((((unsigned char *)(end64buf))[40 +
+1]) << 8)) << 16)) &0xffffffffUL)) | (((jlong
)((((((unsigned char *)(end64buf))[40 +4]) | ((((unsigned char
 *)(end64buf))[40 +4 +1]) << 8)) | (((((unsigned char *
)(end64buf))[40 +4 +2]) | ((((unsigned char *)(end64buf))[40 +
+2 +1]) << 8)) << 16)) &0xffffffffUL)) <<
 32));
          cenoff = ZIP64_ENDOFF(end64buf)(((jlong)((((((unsigned char *)(end64buf))[48]) | ((((unsigned
 char *)(end64buf))[48 +1]) << 8)) | (((((unsigned char
 *)(end64buf))[48 +2]) | ((((unsigned char *)(end64buf))[48 +
+1]) << 8)) << 16)) &0xffffffffUL)) | (((jlong
)((((((unsigned char *)(end64buf))[48 +4]) | ((((unsigned char
 *)(end64buf))[48 +4 +1]) << 8)) | (((((unsigned char *
)(end64buf))[48 +4 +2]) | ((((unsigned char *)(end64buf))[48 +
+2 +1]) << 8)) << 16)) &0xffffffffUL)) <<
 32));
          total = (jint)ZIP64_ENDTOT(end64buf)(((jlong)((((((unsigned char *)(end64buf))[32]) | ((((unsigned
 char *)(end64buf))[32 +1]) << 8)) | (((((unsigned char
 *)(end64buf))[32 +2]) | ((((unsigned char *)(end64buf))[32 +
+1]) << 8)) << 16)) &0xffffffffUL)) | (((jlong
)((((((unsigned char *)(end64buf))[32 +4]) | ((((unsigned char
 *)(end64buf))[32 +4 +1]) << 8)) | (((((unsigned char *
)(end64buf))[32 +4 +2]) | ((((unsigned char *)(end64buf))[32 +
+2 +1]) << 8)) << 16)) &0xffffffffUL)) <<
 32));
          endpos = end64pos;
          endhdrlen = ZIP64_ENDHDR56;
      }
  }

  if (cenlen > endpos) {
22
←
Assuming 'cenlen' is <= 'endpos'→
23
←
Taking false branch→
      ZIP_FORMAT_ERROR("invalid END header (bad central directory size)")if (1) { zip->msg = "invalid END header (bad central directory size)"
; goto Catch; } else ((void)0);
  }
  cenpos = endpos - cenlen;

  /* Get position of first local file (LOC) header, taking into
   * account that there may be a stub prefixed to the zip file. */
  zip->locpos = cenpos - cenoff;
  if (zip->locpos < 0) {
24
←
Assuming field 'locpos' is >= 0→
25
←
Taking false branch→
      ZIP_FORMAT_ERROR("invalid END header (bad central directory offset)")if (1) { zip->msg = "invalid END header (bad central directory offset)"
; goto Catch; } else ((void)0);
  }
629#ifdef USE_MMAP1
  if (zip->usemmap) {
26
←
Assuming field 'usemmap' is 0→
27
←
Taking false branch→
    /* On Solaris & Linux prior to JDK 6, we used to mmap the whole jar file to
     * read the jar file contents. However, this greatly increased the perceived
     * footprint numbers because the mmap'ed pages were adding into the totals shown
     * by 'ps' and 'top'. We switched to mmaping only the central directory of jar
     * file while calling 'read' to read the rest of jar file. Here are a list of
     * reasons apart from above of why we are doing so:
     * 1. Greatly reduces mmap overhead after startup complete;
     * 2. Avoids dual path code maintainance;
     * 3. Greatly reduces risk of address space (not virtual memory) exhaustion.
     */
      if (pagesize == 0) {
          pagesize = (jlong)sysconf(_SC_PAGESIZE_SC_PAGESIZE);
          if (pagesize == 0) goto Catch;
      }
      if (cenpos > pagesize) {
          offset = cenpos & ~(pagesize - 1);
      } else {
          offset = 0;
      }
      /* When we are not calling recursively, knownTotal is -1. */
      if (knownTotal == -1) {
          void* mappedAddr;
          /* Mmap the CEN and END part only. We have to figure
             out the page size in order to make offset to be multiples of
             page size.
          */
          zip->mlen = cenpos - offset + cenlen + endhdrlen;
          zip->offset = offset;
          mappedAddr = mmap64(0, zip->mlen, PROT_READ0x1, MAP_SHARED0x01, zip->zfd, (off64_t) offset);
          zip->maddr = (mappedAddr == (void*) MAP_FAILED((void *) -1)) ? NULL((void*)0) :
              (unsigned char*)mappedAddr;

          if (zip->maddr == NULL((void*)0)) {
              jio_fprintf(stderrstderr, "mmap failed for CEN and END part of zip file\n");
              goto Catch;
          }
      }
      cenbuf = zip->maddr + cenpos - offset;
  } else
670#endif
  {
      if ((cenbuf = malloc((size_t) cenlen)) == NULL((void*)0) ||
28
←
Memory is allocated→
29
←
Assuming the condition is false→
30
←
Taking true branch→
          (readFullyAt(zip->zfd, cenbuf, cenlen, cenpos) == -1))
      goto Catch;
31
←
Control jumps to line 751→
  }

  cenend = cenbuf + cenlen;

  /* Initialize zip file data structures based on the total number
   * of central directory entries as stored in ENDTOT.  Since this
   * is a 2-byte field, but we (and other zip implementations)
   * support approx. 2**31 entries, we do not trust ENDTOT, but
   * treat it only as a strong hint.  When we call ourselves
   * recursively, knownTotal will have the "true" value.
   *
   * Keep this path alive even with the Zip64 END support added, just
   * for zip files that have more than 0xffff entries but don't have
   * the Zip64 enabled.
   */
  total = (knownTotal != -1) ? knownTotal : total;
  entries  = zip->entries  = calloc(total, sizeof(entries[0]));
  tablelen = zip->tablelen = ((total/2) | 1); // Odd -> fewer collisions
  table    = zip->table    = malloc(tablelen * sizeof(table[0]));
  /* According to ISO C it is perfectly legal for malloc to return zero
   * if called with a zero argument. We check this for 'entries' but not
   * for 'table' because 'tablelen' can't be zero (see computation above). */
  if ((entries == NULL((void*)0) && total != 0) || table == NULL((void*)0)) goto Catch;
  for (j = 0; j < tablelen; j++)
      table[j] = ZIP_ENDCHAIN((jint)-1);

  /* Iterate through the entries in the central directory */
  for (i = 0, cp = cenbuf; cp <= cenend - CENHDR46; i++, cp += CENSIZE(cp)(46 + ((((unsigned char *)(cp))[28]) | ((((unsigned char *)(cp
))[28 +1]) << 8)) + ((((unsigned char *)(cp))[30]) | ((
((unsigned char *)(cp))[30 +1]) << 8)) + ((((unsigned char
 *)(cp))[32]) | ((((unsigned char *)(cp))[32 +1]) << 8)
))) {
      /* Following are unsigned 16-bit */
      jint method, nlen;
      unsigned int hsh;

      if (i >= total) {
          /* This will only happen if the zip file has an incorrect
           * ENDTOT field, which usually means it contains more than
           * 65535 entries. */
          cenpos = readCEN(zip, countCENHeaders(cenbuf, cenend));
          goto Finally;
      }

      method = CENHOW(cp)((((unsigned char *)(cp))[10]) | ((((unsigned char *)(cp))[10
 +1]) << 8));
      nlen   = CENNAM(cp)((((unsigned char *)(cp))[28]) | ((((unsigned char *)(cp))[28
 +1]) << 8));

      if (!CENSIG_AT(cp)(((cp)[0] == 'P') & ((cp)[1] == 'K') & ((cp)[2] == 1)
 & ((cp)[3] == 2))) {
          ZIP_FORMAT_ERROR("invalid CEN header (bad signature)")if (1) { zip->msg = "invalid CEN header (bad signature)"; goto
 Catch; } else ((void)0);
      }
      if (CENFLG(cp)((((unsigned char *)(cp))[8]) | ((((unsigned char *)(cp))[8 +
1]) << 8)) & 1) {
          ZIP_FORMAT_ERROR("invalid CEN header (encrypted entry)")if (1) { zip->msg = "invalid CEN header (encrypted entry)"
; goto Catch; } else ((void)0);
      }
      if (method != STORED0 && method != DEFLATED8) {
          ZIP_FORMAT_ERROR("invalid CEN header (bad compression method)")if (1) { zip->msg = "invalid CEN header (bad compression method)"
; goto Catch; } else ((void)0);
      }
      if (cp + CENHDR46 + nlen > cenend) {
          ZIP_FORMAT_ERROR("invalid CEN header (bad header size)")if (1) { zip->msg = "invalid CEN header (bad header size)"
; goto Catch; } else ((void)0);
      }
      /* if the entry is metadata add it to our metadata names */
      if (isMetaName((char *)cp+CENHDR46, nlen))
          if (addMetaName(zip, (char *)cp+CENHDR46, nlen) != 0)
              goto Catch;

      /* Record the CEN offset and the name hash in our hash cell. */
      entries[i].cenpos = cenpos + (cp - cenbuf);
      entries[i].hash = hashN((char *)cp+CENHDR46, nlen);

      /* Add the entry to the hash table */
      hsh = entries[i].hash % tablelen;
      entries[i].next = table[hsh];
      table[hsh] = i;
  }
  if (cp != cenend) {
      ZIP_FORMAT_ERROR("invalid CEN header (bad header size)")if (1) { zip->msg = "invalid CEN header (bad header size)"
; goto Catch; } else ((void)0);
  }
  zip->total = i;
  goto Finally;

Catch:
  freeCEN(zip);
  cenpos = -1;

Finally:
755#ifdef USE_MMAP1
  if (!zip->usemmap)
32
←
Assuming field 'usemmap' is not equal to 0→
33
←
Taking false branch→
757#endif
      free(cenbuf);

  return cenpos;
34
←
Potential leak of memory pointed to by 'cenbuf'
761}

763/*
* Opens a zip file with the specified mode. Returns the jzfile object
* or NULL if an error occurred. If a zip error occurred then *pmsg will
* be set to the error message text if pmsg != 0. Otherwise, *pmsg will be
* set to NULL. Caller is responsible to free the error message.
*/
769jzfile *
770ZIP_Open_Generic(const char *name, char **pmsg, int mode, jlong lastModified)
771{
  jzfile *zip = NULL((void*)0);

  /* Clear zip error message */
  if (pmsg != NULL((void*)0)) {
2
←
Assuming 'pmsg' is not equal to NULL→
3
←
Taking true branch→
      *pmsg = NULL((void*)0);
  }

  zip = ZIP_Get_From_Cache(name, pmsg, lastModified);

  if (zip3.1
'zip' is equal to NULL
 == NULL((void*)0) && pmsg3.2
'pmsg' is not equal to NULL
 != NULL((void*)0) && *pmsg == NULL((void*)0)) {
4
←
Taking true branch→
      ZFILEint zfd = ZFILE_Open(name, mode);
      zip = ZIP_Put_In_Cache(name, zfd, pmsg, lastModified);
5
←
Calling 'ZIP_Put_In_Cache'→
  }
  return zip;
786}

788/*
* Returns the jzfile corresponding to the given file name from the cache of
* zip files, or NULL if the file is not in the cache.  If the name is longer
* than PATH_MAX or a zip error occurred then *pmsg will be set to the error
* message text if pmsg != 0. Otherwise, *pmsg will be set to NULL. Caller
* is responsible to free the error message.
*/
795jzfile *
796ZIP_Get_From_Cache(const char *name, char **pmsg, jlong lastModified)
797{
  char buf[PATH_MAX4096];
  jzfile *zip;

  if (InitializeZip()) {
      return NULL((void*)0);
  }

  /* Clear zip error message */
  if (pmsg != 0) {
      *pmsg = NULL((void*)0);
  }

  if (strlen(name) >= PATH_MAX4096) {
      if (pmsg) {
          *pmsg = strdup("zip file name too long");
      }
      return NULL((void*)0);
  }
  strcpy(buf, name);
  JVM_NativePath(buf);
  name = buf;

  MLOCK(zfiles_lock)JVM_RawMonitorEnter(zfiles_lock);
  for (zip = zfiles; zip != NULL((void*)0); zip = zip->next) {
      if (strcmp(name, zip->name) == 0
          && (zip->lastModified == lastModified || zip->lastModified == 0)
          && zip->refs < MAXREFS0xFFFF) {
          zip->refs++;
          break;
      }
  }
  MUNLOCK(zfiles_lock)JVM_RawMonitorExit(zfiles_lock);
  return zip;
831}

833/*
* Reads data from the given file descriptor to create a jzfile, puts the
* jzfile in a cache, and returns that jzfile.  Returns NULL in case of error.
* If a zip error occurs, then *pmsg will be set to the error message text if
* pmsg != 0. Otherwise, *pmsg will be set to NULL. Caller is responsible to
* free the error message.
*/

841jzfile *
842ZIP_Put_In_Cache(const char *name, ZFILEint zfd, char **pmsg, jlong lastModified)
843{
  return ZIP_Put_In_Cache0(name, zfd, pmsg, lastModified, JNI_TRUE1);
6
←
Calling 'ZIP_Put_In_Cache0'→
845}

847jzfile *
848ZIP_Put_In_Cache0(const char *name, ZFILEint zfd, char **pmsg, jlong lastModified,
               jboolean usemmap)
850{
  char errbuf[256];
  jlong len;
  jzfile *zip;

  if ((zip = allocZip(name)) == NULL((void*)0)) {
7
←
Taking false branch→
      return NULL((void*)0);
  }

859#ifdef USE_MMAP1
  zip->usemmap = usemmap;
861#endif
  zip->refs = 1;
  zip->lastModified = lastModified;

  if (zfd == -1) {
8
←
Assuming the condition is false→
9
←
Taking false branch→
      if (pmsg && getLastErrorString(errbuf, sizeof(errbuf)) > 0)
          *pmsg = strdup(errbuf);
      freeZip(zip);
      return NULL((void*)0);
  }

  // Assumption, zfd refers to start of file. Trivially, reuse errbuf.
  if (readFully(zfd, errbuf, 4) != -1) {  // errors will be handled later
10
←
Assuming the condition is false→
11
←
Taking false branch→
      zip->locsig = LOCSIG_AT(errbuf)(((errbuf)[0] == 'P') & ((errbuf)[1] == 'K') & ((errbuf
)[2] == 3) & ((errbuf)[3] == 4)) ? JNI_TRUE1 : JNI_FALSE0;
  }

  len = zip->len = IO_Lseeklseek64(zfd, 0, SEEK_END2);
  if (len <= 0) {
12
←
Assuming 'len' is > 0→
13
←
Taking false branch→
      if (len == 0) { /* zip file is empty */
          if (pmsg) {
              *pmsg = strdup("zip file is empty");
          }
      } else { /* error */
          if (pmsg && getLastErrorString(errbuf, sizeof(errbuf)) > 0)
              *pmsg = strdup(errbuf);
      }
      ZFILE_Close(zfd);
      freeZip(zip);
      return NULL((void*)0);
  }

  zip->zfd = zfd;
  if (readCEN(zip, -1) < 0) {
14
←
Calling 'readCEN'→
      /* An error occurred while trying to read the zip file */
      if (pmsg != 0) {
          /* Set the zip error message */
          if (zip->msg != NULL((void*)0))
              *pmsg = strdup(zip->msg);
      }
      freeZip(zip);
      return NULL((void*)0);
  }
  MLOCK(zfiles_lock)JVM_RawMonitorEnter(zfiles_lock);
  zip->next = zfiles;
  zfiles = zip;
  MUNLOCK(zfiles_lock)JVM_RawMonitorExit(zfiles_lock);

  return zip;
909}

911/*
* Opens a zip file for reading. Returns the jzfile object or NULL
* if an error occurred. If a zip error occurred then *msg will be
* set to the error message text if msg != 0. Otherwise, *msg will be
* set to NULL. Caller doesn't need to free the error message.
*/
917JNIEXPORT__attribute__((visibility("default"))) jzfile *
918ZIP_Open(const char *name, char **pmsg)
919{
  jzfile *file = ZIP_Open_Generic(name, pmsg, O_RDONLY00, 0);
1
Calling 'ZIP_Open_Generic'→
  if (file == NULL((void*)0) && pmsg != NULL((void*)0) && *pmsg != NULL((void*)0)) {
      free(*pmsg);
      *pmsg = "Zip file open error";
  }
  return file;
926}

928/*
* Closes the specified zip file object.
*/
931JNIEXPORT__attribute__((visibility("default"))) void
932ZIP_Close(jzfile *zip)
933{
  MLOCK(zfiles_lock)JVM_RawMonitorEnter(zfiles_lock);
  if (--zip->refs > 0) {
      /* Still more references so just return */
      MUNLOCK(zfiles_lock)JVM_RawMonitorExit(zfiles_lock);
      return;
  }
  /* No other references so close the file and remove from list */
  if (zfiles == zip) {
      zfiles = zfiles->next;
  } else {
      jzfile *zp;
      for (zp = zfiles; zp->next != 0; zp = zp->next) {
          if (zp->next == zip) {
              zp->next = zip->next;
              break;
          }
      }
  }
  MUNLOCK(zfiles_lock)JVM_RawMonitorExit(zfiles_lock);
  freeZip(zip);
  return;
955}

957/* Empirically, most CEN headers are smaller than this. */
958#define AMPLE_CEN_HEADER_SIZE160 160

960/* A good buffer size when we want to read CEN headers sequentially. */
961#define CENCACHE_PAGESIZE8192 8192

963static char *
964readCENHeader(jzfile *zip, jlong cenpos, jint bufsize)
965{
  jint censize;
  ZFILEint zfd = zip->zfd;
  char *cen;
  if (bufsize > zip->len - cenpos)
      bufsize = (jint)(zip->len - cenpos);
  if ((cen = malloc(bufsize)) == NULL((void*)0))       goto Catch;
  if (readFullyAt(zfd, cen, bufsize, cenpos) == -1)     goto Catch;
  censize = CENSIZE(cen)(46 + ((((unsigned char *)(cen))[28]) | ((((unsigned char *)(
cen))[28 +1]) << 8)) + ((((unsigned char *)(cen))[30]) |
 ((((unsigned char *)(cen))[30 +1]) << 8)) + ((((unsigned
 char *)(cen))[32]) | ((((unsigned char *)(cen))[32 +1]) <<
 8)));
  if (censize <= bufsize) return cen;
  if ((cen = realloc(cen, censize)) == NULL((void*)0))              goto Catch;
  if (readFully(zfd, cen+bufsize, censize-bufsize) == -1) goto Catch;
  return cen;

Catch:
  free(cen);
  return NULL((void*)0);
982}

984static char *
985sequentialAccessReadCENHeader(jzfile *zip, jlong cenpos)
986{
  cencache *cache = &zip->cencache;
  char *cen;
  if (cache->data != NULL((void*)0)
      && (cenpos >= cache->pos)
      && (cenpos + CENHDR46 <= cache->pos + CENCACHE_PAGESIZE8192))
  {
      cen = cache->data + cenpos - cache->pos;
      if (cenpos + CENSIZE(cen)(46 + ((((unsigned char *)(cen))[28]) | ((((unsigned char *)(
cen))[28 +1]) << 8)) + ((((unsigned char *)(cen))[30]) |
 ((((unsigned char *)(cen))[30 +1]) << 8)) + ((((unsigned
 char *)(cen))[32]) | ((((unsigned char *)(cen))[32 +1]) <<
 8))) <= cache->pos + CENCACHE_PAGESIZE8192)
          /* A cache hit */
          return cen;
  }

  if ((cen = readCENHeader(zip, cenpos, CENCACHE_PAGESIZE8192)) == NULL((void*)0))
      return NULL((void*)0);
  free(cache->data);
  cache->data = cen;
  cache->pos  = cenpos;
  return cen;
1005}

1007typedef enum { ACCESS_RANDOM, ACCESS_SEQUENTIAL } AccessHint;

1009/*
* Return a new initialized jzentry corresponding to a given hash cell.
* In case of error, returns NULL.
* We already sanity-checked all the CEN headers for ZIP format errors
* in readCEN(), so we don't check them again here.
* The ZIP lock should be held here.
*/
1016static jzentry *
1017newEntry(jzfile *zip, jzcell *zc, AccessHint accessHint)
1018{
  jlong locoff;
  jint nlen, elen, clen;
  jzentry *ze;
  char *cen;

  if ((ze = (jzentry *) malloc(sizeof(jzentry))) == NULL((void*)0)) return NULL((void*)0);
  ze->name    = NULL((void*)0);
  ze->extra   = NULL((void*)0);
  ze->comment = NULL((void*)0);

1029#ifdef USE_MMAP1
  if (zip->usemmap) {
      cen = (char*) zip->maddr + zc->cenpos - zip->offset;
  } else
1033#endif
  {
      if (accessHint == ACCESS_RANDOM)
          cen = readCENHeader(zip, zc->cenpos, AMPLE_CEN_HEADER_SIZE160);
      else
          cen = sequentialAccessReadCENHeader(zip, zc->cenpos);
      if (cen == NULL((void*)0)) goto Catch;
  }

  nlen      = CENNAM(cen)((((unsigned char *)(cen))[28]) | ((((unsigned char *)(cen))[
+1]) << 8));
  elen      = CENEXT(cen)((((unsigned char *)(cen))[30]) | ((((unsigned char *)(cen))[
+1]) << 8));
  clen      = CENCOM(cen)((((unsigned char *)(cen))[32]) | ((((unsigned char *)(cen))[
+1]) << 8));
  ze->time  = CENTIM(cen)((((((unsigned char *)(cen))[12]) | ((((unsigned char *)(cen)
)[12 +1]) << 8)) | (((((unsigned char *)(cen))[12 +2]) |
 ((((unsigned char *)(cen))[12 +2 +1]) << 8)) << 16
)) &0xffffffffUL);
  ze->size  = CENLEN(cen)((((((unsigned char *)(cen))[24]) | ((((unsigned char *)(cen)
)[24 +1]) << 8)) | (((((unsigned char *)(cen))[24 +2]) |
 ((((unsigned char *)(cen))[24 +2 +1]) << 8)) << 16
)) &0xffffffffUL);
  ze->csize = (CENHOW(cen)((((unsigned char *)(cen))[10]) | ((((unsigned char *)(cen))[
+1]) << 8)) == STORED0) ? 0 : CENSIZ(cen)((((((unsigned char *)(cen))[20]) | ((((unsigned char *)(cen)
)[20 +1]) << 8)) | (((((unsigned char *)(cen))[20 +2]) |
 ((((unsigned char *)(cen))[20 +2 +1]) << 8)) << 16
)) &0xffffffffUL);
  ze->crc   = CENCRC(cen)((((((unsigned char *)(cen))[16]) | ((((unsigned char *)(cen)
)[16 +1]) << 8)) | (((((unsigned char *)(cen))[16 +2]) |
 ((((unsigned char *)(cen))[16 +2 +1]) << 8)) << 16
)) &0xffffffffUL);
  locoff    = CENOFF(cen)((((((unsigned char *)(cen))[42]) | ((((unsigned char *)(cen)
)[42 +1]) << 8)) | (((((unsigned char *)(cen))[42 +2]) |
 ((((unsigned char *)(cen))[42 +2 +1]) << 8)) << 16
)) &0xffffffffUL);
  ze->pos   = -(zip->locpos + locoff);
  ze->flag  = CENFLG(cen)((((unsigned char *)(cen))[8]) | ((((unsigned char *)(cen))[8
 +1]) << 8));

  if ((ze->name = malloc(nlen + 1)) == NULL((void*)0)) goto Catch;
  memcpy(ze->name, cen + CENHDR46, nlen);
  ze->name[nlen] = '\0';
  ze->nlen = nlen;
  if (elen > 0) {
      char *extra = cen + CENHDR46 + nlen;

      /* This entry has "extra" data */
      if ((ze->extra = malloc(elen + 2)) == NULL((void*)0)) goto Catch;
      ze->extra[0] = (unsigned char) elen;
      ze->extra[1] = (unsigned char) (elen >> 8);
      memcpy(ze->extra+2, extra, elen);
      if (ze->csize == ZIP64_MAGICVAL0xffffffffLL || ze->size == ZIP64_MAGICVAL0xffffffffLL ||
          locoff == ZIP64_MAGICVAL0xffffffffLL) {
          jint off = 0;
          while ((off + 4) < elen) {    // spec: HeaderID+DataSize+Data
              jint sz = SH(extra, off + 2)((((unsigned char *)(extra))[off + 2]) | ((((unsigned char *)
(extra))[off + 2 +1]) << 8));
              if (SH(extra, off)((((unsigned char *)(extra))[off]) | ((((unsigned char *)(extra
))[off+1]) << 8)) == ZIP64_EXTID1) {
                  off += 4;
                  if (ze->size == ZIP64_MAGICVAL0xffffffffLL) {
                      // if invalid zip64 extra fields, just skip
                      if (sz < 8 || (off + 8) > elen)
                          break;
                      ze->size = LL(extra, off)(((jlong)((((((unsigned char *)(extra))[off]) | ((((unsigned char
 *)(extra))[off+1]) << 8)) | (((((unsigned char *)(extra
))[off+2]) | ((((unsigned char *)(extra))[off+2 +1]) <<
 8)) << 16)) &0xffffffffUL)) | (((jlong)((((((unsigned
 char *)(extra))[off+4]) | ((((unsigned char *)(extra))[off+4
 +1]) << 8)) | (((((unsigned char *)(extra))[off+4 +2])
 | ((((unsigned char *)(extra))[off+4 +2 +1]) << 8)) <<
 16)) &0xffffffffUL)) << 32));
                      sz -= 8;
                      off += 8;
                  }
                  if (ze->csize == ZIP64_MAGICVAL0xffffffffLL) {
                      if (sz < 8 || (off + 8) > elen)
                          break;
                      ze->csize = LL(extra, off)(((jlong)((((((unsigned char *)(extra))[off]) | ((((unsigned char
 *)(extra))[off+1]) << 8)) | (((((unsigned char *)(extra
))[off+2]) | ((((unsigned char *)(extra))[off+2 +1]) <<
 8)) << 16)) &0xffffffffUL)) | (((jlong)((((((unsigned
 char *)(extra))[off+4]) | ((((unsigned char *)(extra))[off+4
 +1]) << 8)) | (((((unsigned char *)(extra))[off+4 +2])
 | ((((unsigned char *)(extra))[off+4 +2 +1]) << 8)) <<
 16)) &0xffffffffUL)) << 32));
                      sz -= 8;
                      off += 8;
                  }
                  if (locoff == ZIP64_MAGICVAL0xffffffffLL) {
                      if (sz < 8 || (off + 8) > elen)
                          break;
                      ze->pos = -(zip->locpos +  LL(extra, off)(((jlong)((((((unsigned char *)(extra))[off]) | ((((unsigned char
 *)(extra))[off+1]) << 8)) | (((((unsigned char *)(extra
))[off+2]) | ((((unsigned char *)(extra))[off+2 +1]) <<
 8)) << 16)) &0xffffffffUL)) | (((jlong)((((((unsigned
 char *)(extra))[off+4]) | ((((unsigned char *)(extra))[off+4
 +1]) << 8)) | (((((unsigned char *)(extra))[off+4 +2])
 | ((((unsigned char *)(extra))[off+4 +2 +1]) << 8)) <<
 16)) &0xffffffffUL)) << 32)));
                      sz -= 8;
                      off += 8;
                  }
                  break;
              }
              off += (sz + 4);
          }
      }
  }

  if (clen > 0) {
      /* This entry has a comment */
      if ((ze->comment = malloc(clen + 1)) == NULL((void*)0)) goto Catch;
      memcpy(ze->comment, cen + CENHDR46 + nlen + elen, clen);
      ze->comment[clen] = '\0';
  }
  goto Finally;

Catch:
  free(ze->name);
  free(ze->extra);
  free(ze->comment);
  free(ze);
  ze = NULL((void*)0);

Finally:
1117#ifdef USE_MMAP1
  if (!zip->usemmap)
1119#endif
      if (cen != NULL((void*)0) && accessHint == ACCESS_RANDOM) free(cen);
  return ze;
1122}

1124/*
* Free the given jzentry.
* In fact we maintain a one-entry cache of the most recently used
* jzentry for each zip.  This optimizes a common access pattern.
*/

1130void
1131ZIP_FreeEntry(jzfile *jz, jzentry *ze)
1132{
  jzentry *last;
  ZIP_Lock(jz);
  last = jz->cache;
  jz->cache = ze;
  ZIP_Unlock(jz);
  if (last != NULL((void*)0)) {
      /* Free the previously cached jzentry */
      free(last->name);
      if (last->extra)   free(last->extra);
      if (last->comment) free(last->comment);
      free(last);
  }
1145}

1147/*
* Returns the zip entry corresponding to the specified name, or
* NULL if not found.
*/
1151jzentry *
1152ZIP_GetEntry(jzfile *zip, char *name, jint ulen)
1153{
  if (ulen == 0) {
      return ZIP_GetEntry2(zip, name, (jint)strlen(name), JNI_FALSE0);
  }
  return ZIP_GetEntry2(zip, name, ulen, JNI_TRUE1);
1158}

1160jboolean equals(char* name1, int len1, char* name2, int len2) {
  if (len1 != len2) {
      return JNI_FALSE0;
  }
  while (len1-- > 0) {
      if (*name1++ != *name2++) {
          return JNI_FALSE0;
      }
  }
  return JNI_TRUE1;
1170}

1172/*
* Returns the zip entry corresponding to the specified name, or
* NULL if not found.
* This method supports embedded null character in "name", use ulen
* for the length of "name".
*/
1178jzentry *
1179ZIP_GetEntry2(jzfile *zip, char *name, jint ulen, jboolean addSlash)
1180{
  unsigned int hsh = hashN(name, ulen);
  jint idx;
  jzentry *ze = 0;

  ZIP_Lock(zip);
  if (zip->total == 0) {
      goto Finally;
  }

  idx = zip->table[hsh % zip->tablelen];

  /*
   * This while loop is an optimization where a double lookup
   * for name and name+/ is being performed. The name char
   * array has enough room at the end to try again with a
   * slash appended if the first table lookup does not succeed.
   */
  while(1) {

      /* Check the cached entry first */
      ze = zip->cache;
      if (ze && equals(ze->name, ze->nlen, name, ulen)) {
          /* Cache hit!  Remove and return the cached entry. */
          zip->cache = 0;
          ZIP_Unlock(zip);
          return ze;
      }
      ze = 0;

      /*
       * Search down the target hash chain for a cell whose
       * 32 bit hash matches the hashed name.
       */
      while (idx != ZIP_ENDCHAIN((jint)-1)) {
          jzcell *zc = &zip->entries[idx];

          if (zc->hash == hsh) {
              /*
               * OK, we've found a ZIP entry whose 32 bit hashcode
               * matches the name we're looking for.  Try to read
               * its entry information from the CEN.  If the CEN
               * name matches the name we're looking for, we're
               * done.
               * If the names don't match (which should be very rare)
               * we keep searching.
               */
              ze = newEntry(zip, zc, ACCESS_RANDOM);
              if (ze && equals(ze->name, ze->nlen, name, ulen)) {
                  break;
              }
              if (ze != 0) {
                  /* We need to release the lock across the free call */
                  ZIP_Unlock(zip);
                  ZIP_FreeEntry(zip, ze);
                  ZIP_Lock(zip);
              }
              ze = 0;
          }
          idx = zc->next;
      }

      /* Entry found, return it */
      if (ze != 0) {
          break;
      }

      /* If no need to try appending slash, we are done */
      if (!addSlash) {
          break;
      }

      /* Slash is already there? */
      if (ulen > 0 && name[ulen - 1] == '/') {
          break;
      }

      /* Add slash and try once more */
      name[ulen++] = '/';
      name[ulen] = '\0';
      hsh = hash_append(hsh, '/');
      idx = zip->table[hsh % zip->tablelen];
      addSlash = JNI_FALSE0;
  }

1265Finally:
  ZIP_Unlock(zip);
  return ze;
1268}

1270/*
* Returns the n'th (starting at zero) zip file entry, or NULL if the
* specified index was out of range.
*/
1274JNIEXPORT__attribute__((visibility("default"))) jzentry *
1275ZIP_GetNextEntry(jzfile *zip, jint n)
1276{
  jzentry *result;
  if (n < 0 || n >= zip->total) {
      return 0;
  }
  ZIP_Lock(zip);
  result = newEntry(zip, &zip->entries[n], ACCESS_SEQUENTIAL);
  ZIP_Unlock(zip);
  return result;
1285}

1287/*
* Locks the specified zip file for reading.
*/
1290void
1291ZIP_Lock(jzfile *zip)
1292{
  MLOCK(zip->lock)JVM_RawMonitorEnter(zip->lock);
1294}

1296/*
* Unlocks the specified zip file.
*/
1299void
1300ZIP_Unlock(jzfile *zip)
1301{
  MUNLOCK(zip->lock)JVM_RawMonitorExit(zip->lock);
1303}

1305/*
* Returns the offset of the entry data within the zip file.
* Returns -1 if an error occurred, in which case zip->msg will
* contain the error text.
*/
1310jlong
1311ZIP_GetEntryDataOffset(jzfile *zip, jzentry *entry)
1312{
  /* The Zip file spec explicitly allows the LOC extra data size to
   * be different from the CEN extra data size, although the JDK
   * never creates such zip files.  Since we cannot trust the CEN
   * extra data size, we need to read the LOC to determine the entry
   * data offset.  We do this lazily to avoid touching the virtual
   * memory page containing the LOC when initializing jzentry
   * objects.  (This speeds up javac by a factor of 10 when the JDK
   * is installed on a very slow filesystem.)
   */
  if (entry->pos <= 0) {
      unsigned char loc[LOCHDR30];
      if (readFullyAt(zip->zfd, loc, LOCHDR30, -(entry->pos)) == -1) {
          zip->msg = "error reading zip file";
          return -1;
      }
      if (!LOCSIG_AT(loc)(((loc)[0] == 'P') & ((loc)[1] == 'K') & ((loc)[2] ==
 3) & ((loc)[3] == 4))) {
          zip->msg = "invalid LOC header (bad signature)";
          return -1;
      }
      entry->pos = (- entry->pos) + LOCHDR30 + LOCNAM(loc)((((unsigned char *)(loc))[26]) | ((((unsigned char *)(loc))[
+1]) << 8)) + LOCEXT(loc)((((unsigned char *)(loc))[28]) | ((((unsigned char *)(loc))[
+1]) << 8));
  }
  return entry->pos;
1335}

1337/*
* Reads bytes from the specified zip entry. Assumes that the zip
* file had been previously locked with ZIP_Lock(). Returns the
* number of bytes read, or -1 if an error occurred. If zip->msg != 0
* then a zip error occurred and zip->msg contains the error text.
*
* The current implementation does not support reading an entry that
* has the size bigger than 2**32 bytes in ONE invocation.
*/
1346jint
1347ZIP_Read(jzfile *zip, jzentry *entry, jlong pos, void *buf, jint len)
1348{
  jlong entry_size;
  jlong start;

  if (zip == 0) {
      return -1;
  }

  /* Clear previous zip error */
  zip->msg = NULL((void*)0);

  if (entry == 0) {
      zip->msg = "ZIP_Read: jzentry is NULL";
      return -1;
  }

  entry_size = (entry->csize != 0) ? entry->csize : entry->size;

  /* Check specified position */
  if (pos < 0 || pos > entry_size - 1) {
      zip->msg = "ZIP_Read: specified offset out of range";
      return -1;
  }

  /* Check specified length */
  if (len <= 0)
      return 0;
  if (len > entry_size - pos)
      len = (jint)(entry_size - pos);

  /* Get file offset to start reading data */
  start = ZIP_GetEntryDataOffset(zip, entry);
  if (start < 0)
      return -1;
  start += pos;

  if (start + len > zip->len) {
      zip->msg = "ZIP_Read: corrupt zip file: invalid entry size";
      return -1;
  }

  if (readFullyAt(zip->zfd, buf, len, start) == -1) {
      zip->msg = "ZIP_Read: error reading zip file";
      return -1;
  }
  return len;
1394}


1397/* The maximum size of a stack-allocated buffer.
*/
1399#define BUF_SIZE4096 4096

1401/*
* This function is used by the runtime system to load compressed entries
* from ZIP/JAR files specified in the class path. It is defined here
* so that it can be dynamically loaded by the runtime if the zip library
* is found.
*
* The current implementation does not support reading an entry that
* has the size bigger than 2**32 bytes in ONE invocation.
*/
1410jboolean
1411InflateFully(jzfile *zip, jzentry *entry, void *buf, char **msg)
1412{
  z_stream strm;
  char tmp[BUF_SIZE4096];
  jlong pos = 0;
  jlong count = entry->csize;

  *msg = 0; /* Reset error message */

  if (count == 0) {
      *msg = "inflateFully: entry not compressed";
      return JNI_FALSE0;
  }

  memset(&strm, 0, sizeof(z_stream));
  if (inflateInit2(&strm, -MAX_WBITS)inflateInit2_((&strm), (-15), "1.2.11", (int)sizeof(z_stream
)) != Z_OK0) {
      *msg = strm.msg;
      return JNI_FALSE0;
  }

  strm.next_out = buf;
  strm.avail_out = (uInt)entry->size;

  while (count > 0) {
      jint n = count > (jlong)sizeof(tmp) ? (jint)sizeof(tmp) : (jint)count;
      ZIP_Lock(zip);
      n = ZIP_Read(zip, entry, pos, tmp, n);
      ZIP_Unlock(zip);
      if (n <= 0) {
          if (n == 0) {
              *msg = "inflateFully: Unexpected end of file";
          }
          inflateEnd(&strm);
          return JNI_FALSE0;
      }
      pos += n;
      count -= n;
      strm.next_in = (Bytef *)tmp;
      strm.avail_in = n;
      do {
          switch (inflate(&strm, Z_PARTIAL_FLUSH1)) {
          case Z_OK0:
              break;
          case Z_STREAM_END1:
              if (count != 0 || strm.total_out != (uInt)entry->size) {
                  *msg = "inflateFully: Unexpected end of stream";
                  inflateEnd(&strm);
                  return JNI_FALSE0;
              }
              break;
          default:
              break;
          }
      } while (strm.avail_in > 0);
  }

  inflateEnd(&strm);
  return JNI_TRUE1;
1469}

1471/*
* The current implementation does not support reading an entry that
* has the size bigger than 2**32 bytes in ONE invocation.
*/
1475JNIEXPORT__attribute__((visibility("default"))) jzentry *
1476ZIP_FindEntry(jzfile *zip, char *name, jint *sizeP, jint *nameLenP)
1477{
  jzentry *entry = ZIP_GetEntry(zip, name, 0);
  if (entry) {
      *sizeP = (jint)entry->size;
      *nameLenP = (jint)strlen(entry->name);
  }
  return entry;
1484}

1486/*
* Reads a zip file entry into the specified byte array
* When the method completes, it releases the jzentry.
* Note: this is called from the separately delivered VM (hotspot/classic)
* so we have to be careful to maintain the expected behaviour.
*/
1492JNIEXPORT__attribute__((visibility("default"))) jboolean
1493ZIP_ReadEntry(jzfile *zip, jzentry *entry, unsigned char *buf, char *entryname)
1494{
  char *msg;
  char tmpbuf[1024];

  if (entry == 0) {
      jio_fprintf(stderrstderr, "jzentry was invalid");
      return JNI_FALSE0;
  }

  strcpy(entryname, entry->name);
  if (entry->csize == 0) {
      /* Entry is stored */
      jlong pos = 0;
      jlong size = entry->size;
      while (pos < size) {
          jint n;
          jlong limit = ((((jlong) 1) << 31) - 1);
          jint count = (size - pos < limit) ?
              /* These casts suppress a VC++ Internal Compiler Error */
              (jint) (size - pos) :
              (jint) limit;
          ZIP_Lock(zip);
          n = ZIP_Read(zip, entry, pos, buf, count);
          msg = zip->msg;
          ZIP_Unlock(zip);
          if (n == -1) {
              if (msg == 0) {
                  getErrorString(errno(*__errno_location ()), tmpbuf, sizeof(tmpbuf));
                  msg = tmpbuf;
              }
              jio_fprintf(stderrstderr, "%s: %s\n", zip->name, msg);
              return JNI_FALSE0;
          }
          buf += n;
          pos += n;
      }
  } else {
      /* Entry is compressed */
      int ok = InflateFully(zip, entry, buf, &msg);
      if (!ok) {
          if ((msg == NULL((void*)0)) || (*msg == 0)) {
              msg = zip->msg;
          }
          if (msg == 0) {
              getErrorString(errno(*__errno_location ()), tmpbuf, sizeof(tmpbuf));
              msg = tmpbuf;
          }
          jio_fprintf(stderrstderr, "%s: %s\n", zip->name, msg);
          return JNI_FALSE0;
      }
  }

  ZIP_FreeEntry(zip, entry);

  return JNI_TRUE1;
1549}

1551JNIEXPORT__attribute__((visibility("default"))) jboolean
1552ZIP_InflateFully(void *inBuf, jlong inLen, void *outBuf, jlong outLen, char **pmsg)
1553{
  z_stream strm;
  int i = 0;
  memset(&strm, 0, sizeof(z_stream));

  *pmsg = 0; /* Reset error message */

  if (inflateInit2(&strm, MAX_WBITS)inflateInit2_((&strm), (15), "1.2.11", (int)sizeof(z_stream
)) != Z_OK0) {
      *pmsg = strm.msg;
      return JNI_FALSE0;
  }

  strm.next_out = (Bytef *) outBuf;
  strm.avail_out = (uInt)outLen;
  strm.next_in = (Bytef *) inBuf;
  strm.avail_in = (uInt)inLen;

  do {
      switch (inflate(&strm, Z_PARTIAL_FLUSH1)) {
          case Z_OK0:
              break;
          case Z_STREAM_END1:
              if (strm.total_out != (uInt)outLen) {
                  *pmsg = "INFLATER_inflateFully: Unexpected end of stream";
                  inflateEnd(&strm);
                  return JNI_FALSE0;
              }
              break;
          case Z_DATA_ERROR(-3):
              *pmsg = "INFLATER_inflateFully: Compressed data corrupted";
              inflateEnd(&strm);
              return JNI_FALSE0;
          case Z_MEM_ERROR(-4):
              *pmsg = "INFLATER_inflateFully: out of memory";
              inflateEnd(&strm);
              return JNI_FALSE0;
          default:
              *pmsg = "INFLATER_inflateFully: internal error";
              inflateEnd(&strm);
              return JNI_FALSE0;
      }
  } while (strm.avail_in > 0);

  inflateEnd(&strm);
  return JNI_TRUE1;
1598}

1600static voidpf tracking_zlib_alloc(voidpf opaque, uInt items, uInt size) {
size_t* needed = (size_t*) opaque;
*needed += (size_t) items * (size_t) size;
return (voidpf) calloc((size_t) items, (size_t) size);
1604}

1606static void tracking_zlib_free(voidpf opaque, voidpf address) {
free((void*) address);
1608}

1610static voidpf zlib_block_alloc(voidpf opaque, uInt items, uInt size) {
char** range = (char**) opaque;
voidpf result = NULL((void*)0);
size_t needed = (size_t) items * (size_t) size;

if (range[1] - range[0] >= (ptrdiff_t) needed) {
  result = (voidpf) range[0];
  range[0] += needed;
}

return result;
1621}

1623static void zlib_block_free(voidpf opaque, voidpf address) {
/* Nothing to do. */
1625}

1627static char const* deflateInit2Wrapper(z_stream* strm, int level) {
int err = deflateInit2(strm, level >= 0 && level <= 9 ? level : Z_DEFAULT_COMPRESSION,deflateInit2_((strm),(level >= 0 && level <= 9 ?
 level : (-1)),(8),(31),(8), (0), "1.2.11", (int)sizeof(z_stream
))
                       Z_DEFLATED, 31, 8, Z_DEFAULT_STRATEGY)deflateInit2_((strm),(level >= 0 && level <= 9 ?
 level : (-1)),(8),(31),(8), (0), "1.2.11", (int)sizeof(z_stream
));
if (err == Z_MEM_ERROR(-4)) {
  return "Out of memory in deflateInit2";
}

if (err != Z_OK0) {
  return "Internal error in deflateInit2";
}

return NULL((void*)0);
1639}

1641JNIEXPORT__attribute__((visibility("default"))) char const*
1642ZIP_GZip_InitParams(size_t inLen, size_t* outLen, size_t* tmpLen, int level) {
z_stream strm;
*tmpLen = 0;
char const* errorMsg;

memset(&strm, 0, sizeof(z_stream));
strm.zalloc = tracking_zlib_alloc;
strm.zfree = tracking_zlib_free;
strm.opaque = (voidpf) tmpLen;

errorMsg = deflateInit2Wrapper(&strm, level);

if (errorMsg == NULL((void*)0)) {
  *outLen = (size_t) deflateBound(&strm, (uLong) inLen);
  deflateEnd(&strm);
}

return errorMsg;
1660}

1662JNIEXPORT__attribute__((visibility("default"))) size_t
1663ZIP_GZip_Fully(char* inBuf, size_t inLen, char* outBuf, size_t outLen, char* tmp, size_t tmpLen,
             int level, char* comment, char const** pmsg) {
z_stream strm;
gz_header hdr;
int err;
char* block[] = {tmp, tmpLen + tmp};
size_t result = 0;

memset(&strm, 0, sizeof(z_stream));
strm.zalloc = zlib_block_alloc;
strm.zfree = zlib_block_free;
strm.opaque = (voidpf) block;

*pmsg = deflateInit2Wrapper(&strm, level);

if (*pmsg == NULL((void*)0)) {
  strm.next_out = (Bytef *) outBuf;
  strm.avail_out = (uInt) outLen;
  strm.next_in = (Bytef *) inBuf;
  strm.avail_in = (uInt) inLen;

  if (comment != NULL((void*)0)) {
    memset(&hdr, 0, sizeof(hdr));
    hdr.comment = (Bytef*) comment;
    deflateSetHeader(&strm, &hdr);
  }

  err = deflate(&strm, Z_FINISH4);

  if (err == Z_OK0 || err == Z_BUF_ERROR(-5)) {
    *pmsg = "Buffer too small";
  } else if (err != Z_STREAM_END1) {
    *pmsg = "Intern deflate error";
  } else {
    result = (size_t) strm.total_out;
  }

  deflateEnd(&strm);
}

return result;
1704}