/*

 * Copyright (c) 1999, 2006, 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.

 */

/*

 * jexec for J2SE

 *

 * jexec is used by the system to allow execution of JAR files.

 *    Essentially jexec needs to run java and

 *    needs to be a native ISA executable (not a shell script), although

 *    this native ISA executable requirement was a mistake that will be fixed.

 *    (<ISA> is sparc or i386 or amd64).

 *

 *    When you execute a jar file, jexec is executed by the system as follows:

 *      /usr/java/jre/lib/<ISA>/jexec -jar JARFILENAME

 *    so this just needs to be turned into:

 *      /usr/java/jre/bin/java -jar JARFILENAME

 *

 * Solaris systems (new 7's and all 8's) will be looking for jexec at:

 *      /usr/java/jre/lib/<ISA>/jexec

 * Older systems may need to add this to their /etc/system file:

 *      set javaexec:jexec="/usr/java/jre/lib/<ISA>/jexec"

 *     and reboot the machine for this to work.

 *

 * This source should be compiled as:

 *      cc -o jexec jexec.c

 *

 * And jexec should be placed at the following location of the installation:

 *      <INSTALLATIONDIR>/jre/lib/<ISA>/jexec  (for Solaris)

 *      <INSTALLATIONDIR>/lib/jexec            (for Linux)

 *

 * NOTE: Unless <INSTALLATIONDIR> is the "default" JDK on the system

 *       (i.e. /usr/java -> <INSTALLATIONDIR>), this jexec will not be

 *       found.  The 1.2 java is only the default on Solaris 8 and

 *       on systems where the 1.2 packages were installed and no 1.1

 *       java was found.

 *

 * NOTE: You must use 1.2 jar to build your jar files. The system

 *       doesn't seem to pick up 1.1 jar files.

 *

 * NOTE: We don't need to set LD_LIBRARY_PATH here, even though we

 *       are running the actual java binary because the java binary will

 *       look for it's libraries through it's own runpath, which uses

 *       $ORIGIN.

 *

 * NOTE: This jexec should NOT have any special .so library needs because

 *       it appears that this executable will NOT get the $ORIGIN of jexec

 *       but the $ORIGIN of the jar file being executed. Be careful to keep

 *       this program simple and with no .so dependencies.

 */

#include <stdlib.h>

#include <stdio.h>

#include <unistd.h>

#include <string.h>

#include <limits.h>

#include <errno.h>

#ifdef __linux__

#  include <sys/types.h>

#  include <sys/stat.h>

#  include <fcntl.h>

#  include "manifest_info.h"

#endif

static const int CRAZY_EXEC = ENOEXEC;

static const int BAD_MAGIC  = ENOEXEC;

static const char * BAD_EXEC_MSG     = "jexec failed";

static const char * CRAZY_EXEC_MSG   = "missing args";

static const char * MISSING_JAVA_MSG = "can't locate java";

#ifdef __linux__

static const char * BAD_PATHNAME_MSG = "invalid path";

static const char * BAD_FILE_MSG     = "invalid file";

static const char * BAD_MAGIC_MSG    = "invalid file (bad magic number)";

#endif

static const char * UNKNOWN_ERROR    = "unknown error";

/* Define a constant that represents the number of directories to pop off the

 * current location to find the java binary */

#ifdef __linux__

static const int RELATIVE_DEPTH = 2;

#else /* Solaris */

static const int RELATIVE_DEPTH = 3;

#endif

/* path to java after popping */

static const char * BIN_PATH = "/bin/java";

/* flag used when running JAR files */

static const char * JAR_FLAG = "-jar";

#ifdef __linux__

/* largest possible size for a local file header */

static const size_t CHUNK_SIZE = 65535;

/* smallest possible size for a local file header */

static const ssize_t MIN_SIZE = LOCHDR + 1 + 4;

#endif

int main(int argc, const char * argv[]);

void errorExit(int error, const char * message);

int getJavaPath(const char * path, char * buf, int depth);

#ifdef __linux__

const char * isJar(const char * path);

#endif

/*

 * This is the main entry point.  This program (jexec) will attempt to execute

 * a JAR file by finding the Java program (java), relative to its own location.

 * The exact location of the Java program depends on the platform, i.e.

 *

 *      <INSTALLATIONDIR>/jre/lib/<ISA>/jexec  (for Solaris)

 *      <INSTALLATIONDIR>/lib/jexec            (for Linux JDK)

 *

 * Once the Java program is found, this program copies any remaining arguments

 * into another array, which is then used to exec the Java program.

 *

 * On Linux this program does some additional steps.  When copying the array of

 * args, it is necessary to insert the "-jar" flag between arg[0], the program

 * name, and the original arg[1], which is presumed to be a path to a JAR file.

 * It is also necessary to verify that the original arg[1] really is a JAR file.

 * (These steps are unnecessary on Solaris because they are taken care of by

 * the kernel.)

 */

int main(int argc, const char * argv[]) {

    /* We need to exec the original arguments using java, instead of jexec.

     * Also, for Linux, it is necessary to add the "-jar" argument between

     * the new arg[0], and the old arg[1].  To do this we will create a new

     * args array. */

    char          java[PATH_MAX + 1];    /* path to java binary  */

    const char ** nargv = NULL;          /* new args array       */

    int           nargc = 0;             /* new args array count */

    int           argi  = 0;             /* index into old array */

    /* Make sure we have something to work with */

    if ((argc < 1) || (argv == NULL)) {

        /* Shouldn't happen... */

        errorExit(CRAZY_EXEC, CRAZY_EXEC_MSG);

    }

    /* Get the path to the java binary, which is in a known position relative

     * to our current position, which is in argv[0]. */

    if (getJavaPath(argv[argi++], java, RELATIVE_DEPTH) != 0) {

        errorExit(errno, MISSING_JAVA_MSG);

    }

    nargv = (const char **) malloc((argc + 2) * (sizeof (const char *)));

    nargv[nargc++] = java;

#ifdef __linux__

    /* The "-jar" flag is already in the original args list on Solaris,

     * so it only needs to be added on Linux. */

    nargv[nargc++] = JAR_FLAG;

#endif

    if (argc >= 2) {

        const char * jarfile = argv[argi++];

        const char * message = NULL;

#ifdef __linux__

        /* On Linux we also need to make sure argv[1] is really a JAR

         * file (this will also resolve any symlinks, which helps). */

        char jarPath[PATH_MAX + 1];

        if (realpath(jarfile, jarPath) == NULL) {

            errorExit(errno, BAD_PATHNAME_MSG);

        }

        message = isJar(jarPath);

        if (message != NULL) {

            errorExit(errno, message);

        }

        jarfile = jarPath;

#endif

        /* the next argument is the path to the JAR file */

        nargv[nargc++] = jarfile;

    }

    /* finally copy any remaining arguments */

    while (argi < argc) {

        nargv[nargc++] = argv[argi++];

    }

    /* finally add one last terminating null */

    nargv[nargc++] = NULL;

    /* It's time to exec the java binary with the new arguments.  It

     * is possible that we've reached this point without actually

     * having a JAR file argument (i.e. if argc < 2), but we still

     * want to exec the java binary, since that will take care of

     * displaying the correct usage. */

    execv(java, (char * const *) nargv);

    /* If the exec worked, this process would have been replaced

     * by the new process.  So any code reached beyond this point

     * implies an error in the exec. */

    free(nargv);

    errorExit(errno, BAD_EXEC_MSG);

}

/*

 * Exit the application by setting errno, and writing a message.

 *

 * Parameters:

 *     error   - errno is set to this value, and it is used to exit.

 *     message - the message to write.

 */

void errorExit(int error, const char * message) {

    if (error != 0) {

        errno = error;

        perror((message != NULL) ? message : UNKNOWN_ERROR);

    }

    exit((error == 0) ? 0 : 1);

}

/*

 * Get the path to the java binary that should be relative to the current path.

 *

 * Parameters:

 *     path  - the input path that the java binary that should be relative to.

 *     buf   - a buffer of size PATH_MAX or greater that the java path is

 *             copied to.

 *     depth - the number of names to trim off the current path, including the

 *             name of this program.

 *

 * Returns:

 *     This function returns 0 on success; otherwise it returns the value of

 *     errno.

 */

int getJavaPath(const char * path, char * buf, int depth) {

    int result = 0;

    /* Get the full path to this program.  Depending on whether this is Solaris

     * or Linux, this will be something like,

     *

     *     <FOO>/jre/lib/<ISA>/jexec  (for Solaris)

     *     <FOO>/lib/jexec            (for Linux)

     */

    if (realpath(path, buf) != NULL) {

        int count = 0;

        /* Pop off the filename, and then subdirectories for each level of

         * depth */

        for (count = 0; count < depth; count++) {

            *(strrchr(buf, '/')) = '\0';

        }

        /* Append the relative location of java, creating something like,

         *

         *     <FOO>/jre/bin/java  (for Solaris)

         *     <FOO>/bin/java      (for Linux)

         */

        strcat(buf, BIN_PATH);

    }

    else {

        /* Failed to get the path */

        result = errno;

    }

    return (result);

}

#ifdef __linux__

/*

 * Check if the given file is a JAR file.

 *

 * Parameters:

 *     path  - the path to the file to check for JAR magic.

 *

 * Returns:

 *     This function return NULL on success.  Otherwise, errno is set, and it

 *     returns a message that indicates what caused the failure.

 */

const char * isJar(const char * path) {

    const char * result = BAD_FILE_MSG;

    int fd = open(path, O_RDONLY);

    if (fd != -1) {

        unsigned char buf[CHUNK_SIZE];

        ssize_t count = read(fd, buf, CHUNK_SIZE);

        if (count >= MIN_SIZE) {

            result = BAD_MAGIC_MSG;

            // be sure the file is at least a ZIP file

            if (GETSIG(buf) == LOCSIG) {

                off_t flen  = LOCNAM(buf);

                off_t xlen  = LOCEXT(buf);

                off_t start = LOCHDR + flen;

                off_t end   = start  + xlen;

                if (end <= count) {

                    while (start < end) {

                        off_t xhid  = SH(buf, start);

                        off_t xdlen = SH(buf, start + 2);

                        start += 4 + xdlen;

                        if (xhid == 0xcafe) {

                            // found the JAR magic

                            result = NULL;

                            break;

                        }

                    }

                }

            }

        }

        if (result != NULL) {

            errno = BAD_MAGIC;

        }

        close (fd);

    }

    return (result);

}

#endif