/*

 * Copyright (c) 1995, 2016, 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.

 */

/*

 * Support for reading ZIP/JAR files.

 */

#include <stdio.h>

#include <stdlib.h>

#include <stddef.h>

#include <string.h>

#include <fcntl.h>

#include <limits.h>

#include <time.h>

#include <ctype.h>

#include <assert.h>

#include "jni.h"

#include "jni_util.h"

#include "jlong.h"

#include "jvm.h"

#include "io_util.h"

#include "io_util_md.h"

#include "zip_util.h"

#include <zlib.h>

#ifdef _ALLBSD_SOURCE

#define off64_t off_t

#define mmap64 mmap

#endif

/* USE_MMAP means mmap the CEN & ENDHDR part of the zip file. */

#ifdef USE_MMAP

#include <sys/mman.h>

#endif

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

#define MCREATE()      JVM_RawMonitorCreate()

#define MLOCK(lock)    JVM_RawMonitorEnter(lock)

#define MUNLOCK(lock)  JVM_RawMonitorExit(lock)

#define MDESTROY(lock) JVM_RawMonitorDestroy(lock)

#define CENSIZE(cen) (CENHDR + CENNAM(cen) + CENEXT(cen) + CENCOM(cen))

static jzfile *zfiles = 0;      /* currently open zip files */

static void *zfiles_lock = 0;

static void freeCEN(jzfile *);

#ifndef PATH_MAX

#define PATH_MAX 1024

#endif

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

/*

 * Declare library specific JNI_Onload entry if static build

 */

#ifdef STATIC_BUILD

DEF_STATIC_JNI_OnLoad

#endif

/*

 * The ZFILE_* functions exist to provide some platform-independence with

 * respect to file access needs.

 */

/*

 * 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.

 */

static ZFILE

ZFILE_Open(const char *fname, int flags) {

#ifdef WIN32

    const DWORD access =

        (flags & O_RDWR)   ? (GENERIC_WRITE | GENERIC_READ) :

        (flags & O_WRONLY) ?  GENERIC_WRITE :

        GENERIC_READ;

    const DWORD sharing =

        FILE_SHARE_READ | FILE_SHARE_WRITE;

    const DWORD disposition =

        /* Note: O_TRUNC overrides O_CREAT */

        (flags & O_TRUNC) ? CREATE_ALWAYS :

        (flags & O_CREAT) ? OPEN_ALWAYS   :

        OPEN_EXISTING;

    const DWORD  maybeWriteThrough =

        (flags & (O_SYNC | O_DSYNC)) ?

        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;

    return (jlong) CreateFile(

        fname,          /* Wide char path name */

        access,         /* Read and/or write permission */

        sharing,        /* File sharing flags */

        NULL,           /* Security attributes */

        disposition,        /* creation disposition */

        flagsAndAttributes, /* flags and attributes */

        NULL);

#else

    return open(fname, flags, 0);

#endif

}

/*

 * The io_util_md.h files do not provide IO_CLOSE, hence we use platform

 * specifics.

 */

static void

ZFILE_Close(ZFILE zfd) {

#ifdef WIN32

    CloseHandle((HANDLE) zfd);

#else

    close(zfd);

#endif

}

static int

ZFILE_read(ZFILE zfd, char *buf, jint nbytes) {

#ifdef WIN32

    return (int) IO_Read(zfd, buf, nbytes);

#else

    return read(zfd, buf, nbytes);

#endif

}

/*

 * Initialize zip file support. Return 0 if successful otherwise -1

 * if could not be initialized.

 */

static jint

{

    static jboolean inited = JNI_FALSE;

    // Initialize errno to 0.  It may be set later (e.g. during memory

    // allocation) but we can disregard previous values.

    errno = 0;

    if (inited)

        return 0;

    zfiles_lock = MCREATE();

    if (zfiles_lock == 0) {

        return -1;

    }

    inited = JNI_TRUE;

    return 0;

}

/*

 * Reads len bytes of data into buf.

 * Returns 0 if all bytes could be read, otherwise returns -1.

 */

static int

readFully(ZFILE 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 == EINTR) {

          /* Retry after EINTR (interrupted by signal). */

            continue;

        } else { /* EOF or IO error */

            return -1;

        }

    }

    return 0;

}

/*

 * Reads len bytes of data from the specified offset into buf.

 * Returns 0 if all bytes could be read, otherwise returns -1.

 */

static int

readFullyAt(ZFILE zfd, void *buf, jlong len, jlong offset)

{

    if (IO_Lseek(zfd, offset, SEEK_SET) == -1) {

        return -1; /* lseek failure. */

    }

    return readFully(zfd, buf, len);

}

/*

 * Allocates a new zip file object for the specified file name.

 * Returns the zip file object or NULL if not enough memory.

 */

static jzfile *

allocZip(const char *name)

{

    jzfile *zip;

    if (((zip = calloc(1, sizeof(jzfile))) != NULL) &&

        ((zip->name = strdup(name))        != NULL) &&

        ((zip->lock = MCREATE())           != NULL)) {

        zip->zfd = -1;

        return zip;

    }

    if (zip != NULL) {

        free(zip->name);

        free(zip);

    }

    return NULL;

}

/*

 * Frees all native resources owned by the specified zip file object.

 */

static void

freeZip(jzfile *zip)

{

    /* First free any cached jzentry */

    ZIP_FreeEntry(zip,0);

    if (zip->lock != NULL) MDESTROY(zip->lock);

    free(zip->name);

    freeCEN(zip);

#ifdef USE_MMAP

    if (zip->usemmap) {

        if (zip->maddr != NULL)

            munmap((char *)zip->maddr, zip->mlen);

    } else

#endif

    {

        free(zip->cencache.data);

    }

    if (zip->comment != NULL)

        free(zip->comment);

    if (zip->zfd != -1) ZFILE_Close(zip->zfd);

    free(zip);

}

/* The END header is followed by a variable length comment of size < 64k. */

static const jlong END_MAXLEN = 0xFFFF + ENDHDR;

#define READBLOCKSZ 128

static 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);

    jlong locpos = cenpos - ENDOFF(endbuf);

    char buf[4];

    return (cenpos >= 0 &&

            locpos >= 0 &&

            readFullyAt(zip->zfd, buf, sizeof(buf), cenpos) != -1 &&

            CENSIG_AT(buf) &&

            readFullyAt(zip->zfd, buf, sizeof(buf), locpos) != -1 &&

            LOCSIG_AT(buf));

}

/*

 * 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.

 */

static jlong

findEND(jzfile *zip, void *endbuf)

{

    char buf[READBLOCKSZ];

    jlong pos;

    const jlong len = zip->len;

    const ZFILE zfd = zip->zfd;

    const jlong minHDR = len - END_MAXLEN > 0 ? len - END_MAXLEN : 0;

    const jlong minPos = minHDR - (sizeof(buf)-ENDHDR);

    jint clen;

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

        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) - ENDHDR; i >= 0; i--) {

            if (buf[i+0] == 'P'    &&

                buf[i+1] == 'K'    &&

                buf[i+2] == '\005' &&

                buf[i+3] == '\006' &&

                ((pos + i + ENDHDR + ENDCOM(buf + i) == len)

                 || verifyEND(zip, pos + i, buf + i))) {

                /* Found END header */

                memcpy(endbuf, buf + i, ENDHDR);

                clen = ENDCOM(endbuf);

                if (clen != 0) {

                    zip->comment = malloc(clen + 1);

                    if (zip->comment == NULL) {

                        return -1;

                    }

                    if (readFullyAt(zfd, zip->comment, clen, pos + i + ENDHDR)

                        == -1) {

                        free(zip->comment);

                        zip->comment = NULL;

                        return -1;

                    }

                    zip->comment[clen] = '\0';

                    zip->clen = clen;

                }

                return pos + i;

            }

        }

    }

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

}

/*

 * 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.

 */

static jlong

findEND64(jzfile *zip, void *end64buf, jlong endpos)

{

    char loc64[ZIP64_LOCHDR];

    jlong end64pos;

    if (readFullyAt(zip->zfd, loc64, ZIP64_LOCHDR, endpos - ZIP64_LOCHDR) == -1) {

        return -1;    // end64 locator not found

    }

    end64pos = ZIP64_LOCOFF(loc64);

    if (readFullyAt(zip->zfd, end64buf, ZIP64_ENDHDR, end64pos) == -1) {

        return -1;    // end64 record not found

    }

    return end64pos;

}

/*

 * Returns a hash code value for a C-style NUL-terminated string.

 */

static unsigned int

hash(const char *s)

{

    int h = 0;

    while (*s != '\0')

        h = 31*h + *s++;

    return h;

}

/*

 * Returns a hash code value for a string of a specified length.

 */

static unsigned int

hashN(const char *s, int length)

{

    int h = 0;

    while (length-- > 0)

        h = 31*h + *s++;

    return h;

}

static unsigned int

hash_append(unsigned int hash, char c)

{

    return ((int)hash)*31 + c;

}

/*

 * Returns true if the specified entry's name begins with the string

 * "META-INF/" irrespective of case.

 */

static int

isMetaName(const char *name, int length)

{

    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;

}

/*

 * Increases the capacity of zip->metanames.

 * Returns non-zero in case of allocation error.

 */

static int

growMetaNames(jzfile *zip)

{

    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) return -1;

    for (i = zip->metacount; i < new_metacount; i++)

        zip->metanames[i] = NULL;

    zip->metacurrent = zip->metacount;

    zip->metacount = new_metacount;

    return 0;

}

/*

 * Adds name to zip->metanames.

 * Returns non-zero in case of allocation error.

 */

static int

addMetaName(jzfile *zip, const char *name, int length)

{

    jint i;

    if (zip->metanames == NULL) {

      zip->metacount = INITIAL_META_COUNT;

      zip->metanames = calloc(zip->metacount, sizeof(zip->metanames[0]));

      if (zip->metanames == NULL) 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) 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);

}

static void

freeMetaNames(jzfile *zip)

{

    if (zip->metanames) {

        jint i;

        for (i = 0; i < zip->metacount; i++)

            free(zip->metanames[i]);

        free(zip->metanames);

        zip->metanames = NULL;

    }

}

/* Free Zip data allocated by readCEN() */

static void

freeCEN(jzfile *zip)

{

    free(zip->entries); zip->entries = NULL;

    free(zip->table);   zip->table   = NULL;

    freeMetaNames(zip);

}

/*

 * Counts the number of CEN headers in a central directory extending