/*

 * Copyright 1995-2009 Sun Microsystems, Inc.  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.  Sun designates this

 * particular file as subject to the "Classpath" exception as provided

 * by Sun 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 Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

 * CA 95054 USA or visit www.sun.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"

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

/*

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

    JVM_Close(zfd);

#endif

}

static int

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

#ifdef WIN32

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

#else

    /*

     * Calling JVM_Read will return JVM_IO_INTR when Thread.interrupt is called

     * only on Solaris. Continue reading jar file in this case is the best

     * thing to do since zip file reading is relatively fast and it is very onerous

     * for a interrupted thread to deal with this kind of hidden I/O. However, handling

     * JVM_IO_INTR is tricky and could cause undesired side effect. So we decided

     * to simply call "read" on Solaris/Linux. See details in bug 6304463.

     */

    return read(zfd, buf, nbytes);

#endif

}

/*

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

 * if could not be initialized.

 */

static jint

InitializeZip()

{

    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 == JVM_IO_ERR && errno == EINTR) {

          /* Retry after EINTR (interrupted by signal).

             We depend on the fact that JVM_IO_ERR == -1. */

            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->maddr != NULL) munmap((char *)zip->maddr, zip->mlen);

#else

    free(zip->cencache.data);

#endif

    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

/*

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

    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', 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' &&

            }

        }

    }

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

 * from BEG to END.  Might return a bogus answer if the zip file is

 * corrupt, but will not crash.

 */

static jint

countCENHeaders(unsigned char *beg, unsigned char *end)

{

    jint count = 0;

    ptrdiff_t i;

    for (i = 0; i + CENHDR < end - beg; i += CENSIZE(beg + i))

        count++;

    return count;

}