/*

 * Copyright (c) 1997, 2010, 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.

 */

#include <windows.h>

#include <io.h>

#include <process.h>

#include <stdlib.h>

#include <stdio.h>

#include <stdarg.h>

#include <string.h>

#include <sys/types.h>

#include <sys/stat.h>

#include <wtypes.h>

#include <commctrl.h>

#include <jni.h>

#include "java.h"

#include "version_comp.h"

#define JVM_DLL "jvm.dll"

#define JAVA_DLL "java.dll"

/*

 * Prototypes.

 */

static jboolean GetPublicJREHome(char *path, jint pathsize);

static jboolean GetJVMPath(const char *jrepath, const char *jvmtype,

                           char *jvmpath, jint jvmpathsize);

static jboolean GetJREPath(char *path, jint pathsize);

static void EnsureJreInstallation(const char *jrepath);

static jboolean _isjavaw = JNI_FALSE;

jboolean

IsJavaw()

{

    return _isjavaw;

}

/*

 * Returns the arch path, to get the current arch use the

 * macro GetArch, nbits here is ignored for now.

 */

const char *

GetArchPath(int nbits)

{

#ifdef _M_AMD64

    return "amd64";

#elif defined(_M_IA64)

    return "ia64";

#else

    return "i386";

#endif

}

/*

 *

 */

void

CreateExecutionEnvironment(int *pargc, char ***pargv,

                           char *jrepath, jint so_jrepath,

                           char *jvmpath, jint so_jvmpath) {

    char * jvmtype;

    int i = 0;

    int running = CURRENT_DATA_MODEL;

    int wanted = running;

    char** argv = *pargv;

    for (i = 0; i < *pargc ; i++) {

        if (JLI_StrCmp(argv[i], "-J-d64") == 0 || JLI_StrCmp(argv[i], "-d64") == 0) {

            wanted = 64;

            continue;

        }

        if (JLI_StrCmp(argv[i], "-J-d32") == 0 || JLI_StrCmp(argv[i], "-d32") == 0) {

            wanted = 32;

            continue;

        }

    }

    if (running != wanted) {

        JLI_ReportErrorMessage(JRE_ERROR2, wanted);

        exit(1);

    }

    /* Find out where the JRE is that we will be using. */

    if (!GetJREPath(jrepath, so_jrepath)) {

        JLI_ReportErrorMessage(JRE_ERROR1);

        exit(2);

    }

    /* Do this before we read jvm.cfg and after jrepath is initialized */

    EnsureJreInstallation(jrepath);

    /* Find the specified JVM type */

    if (ReadKnownVMs(jrepath, (char*)GetArch(), JNI_FALSE) < 1) {

        JLI_ReportErrorMessage(CFG_ERROR7);

        exit(1);

    }

    jvmtype = CheckJvmType(pargc, pargv, JNI_FALSE);

    if (JLI_StrCmp(jvmtype, "ERROR") == 0) {

        JLI_ReportErrorMessage(CFG_ERROR9);

        exit(4);

    }

    jvmpath[0] = '\0';

    if (!GetJVMPath(jrepath, jvmtype, jvmpath, so_jvmpath)) {

        JLI_ReportErrorMessage(CFG_ERROR8, jvmtype, jvmpath);

        exit(4);

    }

    /* If we got here, jvmpath has been correctly initialized. */

}

static jboolean

LoadMSVCRT()

{

    // Only do this once

    static int loaded = 0;

    char crtpath[MAXPATHLEN];

    if (!loaded) {

        /*

         * The Microsoft C Runtime Library needs to be loaded first.  A copy is

         * assumed to be present in the "JRE path" directory.  If it is not found

         * there (or "JRE path" fails to resolve), skip the explicit load and let

         * nature take its course, which is likely to be a failure to execute.

         * This is clearly completely specific to the exact compiler version

         * which isn't very nice, but its hardly the only place.

         * No attempt to look for compiler versions in between 2003 and 2010

         * as we aren't supporting building with those.

         */

#ifdef _MSC_VER

#if _MSC_VER < 1400

#define CRT_DLL "msvcr71.dll"

#endif

#if _MSC_VER >= 1600

#define CRT_DLL "msvcr100.dll"

#endif

#ifdef CRT_DLL

        if (GetJREPath(crtpath, MAXPATHLEN)) {

            (void)JLI_StrCat(crtpath, "\\bin\\" CRT_DLL);   /* Add crt dll */

            JLI_TraceLauncher("CRT path is %s\n", crtpath);

            if (_access(crtpath, 0) == 0) {

                if (LoadLibrary(crtpath) == 0) {

                    JLI_ReportErrorMessage(DLL_ERROR4, crtpath);

                    return JNI_FALSE;

                }

            }

        }

#endif /* CRT_DLL */

#endif /* _MSC_VER */

        loaded = 1;

    }

    return JNI_TRUE;

}

/*

 * The preJVMStart is a function in the jkernel.dll, which

 * performs the final step of synthesizing back the decomposed

 * modules  (partial install) to the full JRE. Any tool which

 * uses the  JRE must peform this step to ensure the complete synthesis.

 * The EnsureJreInstallation function calls preJVMStart based on

 * the conditions outlined below, noting that the operation

 * will fail silently if any of conditions are not met.

 * NOTE: this call must be made before jvm.dll is loaded, or jvm.cfg

 * is read, since jvm.cfg will be modified by the preJVMStart.

 * 1. Are we on a supported platform.

 * 2. Find the location of the JRE or the Kernel JRE.

 * 3. check existence of JREHOME/lib/bundles

 * 4. check jkernel.dll and invoke the entry-point

 */

typedef VOID (WINAPI *PREJVMSTART)();

static void

EnsureJreInstallation(const char* jrepath)

{

    HINSTANCE handle;

    char tmpbuf[MAXPATHLEN];

    PREJVMSTART PreJVMStart;

    struct stat s;

    /* Make sure the jrepath contains something */

    if (jrepath[0] == NULL) {

        return;

    }

    /* 32 bit windows only please */

    if (JLI_StrCmp(GetArch(), "i386") != 0 ) {

        return;

    }

    /* Does our bundle directory exist ? */

    JLI_Snprintf(tmpbuf, sizeof(tmpbuf), "%s\\lib\\bundles", jrepath);

    JLI_TraceLauncher("EnsureJreInstallation: %s\n", tmpbuf);

    if (stat(tmpbuf, &s) != 0) {

        return;

    }

    /* Does our jkernel dll exist ? */

    JLI_Snprintf(tmpbuf, sizeof(tmpbuf), "%s\\bin\\jkernel.dll", jrepath);

    if (stat(tmpbuf, &s) != 0) {

        return;

    }

    /* The Microsoft C Runtime Library needs to be loaded first. */

    if (!LoadMSVCRT()) {

        return;

    }

    /* Load the jkernel.dll */

    if ((handle = LoadLibrary(tmpbuf)) == 0) {

        return;

    }

    /* Get the function address */

    PreJVMStart = (PREJVMSTART)GetProcAddress(handle, "preJVMStart");

    if (PreJVMStart == NULL) {

        FreeLibrary(handle);

        return;

    }

    PreJVMStart();

    FreeLibrary(handle);

    return;

}

/*

 * Find path to JRE based on .exe's location or registry settings.

 */

jboolean

GetJREPath(char *path, jint pathsize)

{

    char javadll[MAXPATHLEN];

    struct stat s;

    if (GetApplicationHome(path, pathsize)) {

        /* Is JRE co-located with the application? */

        JLI_Snprintf(javadll, sizeof(javadll), "%s\\bin\\" JAVA_DLL, path);

        if (stat(javadll, &s) == 0) {

            JLI_TraceLauncher("JRE path is %s\n", path);

            return JNI_TRUE;

        }

        /* Does this app ship a private JRE in <apphome>\jre directory? */

        JLI_Snprintf(javadll, sizeof (javadll), "%s\\jre\\bin\\" JAVA_DLL, path);

        if (stat(javadll, &s) == 0) {

            JLI_StrCat(path, "\\jre");

            JLI_TraceLauncher("JRE path is %s\n", path);

            return JNI_TRUE;

        }

    }

    /* Look for a public JRE on this machine. */

    if (GetPublicJREHome(path, pathsize)) {

        JLI_TraceLauncher("JRE path is %s\n", path);

        return JNI_TRUE;

    }

    JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL);

    return JNI_FALSE;

}

/*

 * Given a JRE location and a JVM type, construct what the name the

 * JVM shared library will be.  Return true, if such a library

 * exists, false otherwise.

 */

static jboolean

GetJVMPath(const char *jrepath, const char *jvmtype,

           char *jvmpath, jint jvmpathsize)

{

    struct stat s;

    if (JLI_StrChr(jvmtype, '/') || JLI_StrChr(jvmtype, '\\')) {

        JLI_Snprintf(jvmpath, jvmpathsize, "%s\\" JVM_DLL, jvmtype);

    } else {

        JLI_Snprintf(jvmpath, jvmpathsize, "%s\\bin\\%s\\" JVM_DLL, jrepath, jvmtype);

    }

    if (stat(jvmpath, &s) == 0) {

        return JNI_TRUE;

    } else {

        return JNI_FALSE;

    }

}

/*

 * Load a jvm from "jvmpath" and initialize the invocation functions.

 */

jboolean

LoadJavaVM(const char *jvmpath, InvocationFunctions *ifn)

{

    HINSTANCE handle;

    JLI_TraceLauncher("JVM path is %s\n", jvmpath);

    /*

     * The Microsoft C Runtime Library needs to be loaded first.  A copy is

     * assumed to be present in the "JRE path" directory.  If it is not found

     * there (or "JRE path" fails to resolve), skip the explicit load and let

     * nature take its course, which is likely to be a failure to execute.

     *

     */

    LoadMSVCRT();

    /* Load the Java VM DLL */

    if ((handle = LoadLibrary(jvmpath)) == 0) {

        JLI_ReportErrorMessage(DLL_ERROR4, (char *)jvmpath);

        return JNI_FALSE;

    }

    /* Now get the function addresses */

    ifn->CreateJavaVM =

        (void *)GetProcAddress(handle, "JNI_CreateJavaVM");

    ifn->GetDefaultJavaVMInitArgs =

        (void *)GetProcAddress(handle, "JNI_GetDefaultJavaVMInitArgs");

    if (ifn->CreateJavaVM == 0 || ifn->GetDefaultJavaVMInitArgs == 0) {

        JLI_ReportErrorMessage(JNI_ERROR1, (char *)jvmpath);

        return JNI_FALSE;

    }

    return JNI_TRUE;

}

/*

 * If app is "c:\foo\bin\javac", then put "c:\foo" into buf.

 */

jboolean

GetApplicationHome(char *buf, jint bufsize)

{

    char *cp;

    GetModuleFileName(0, buf, bufsize);

    *JLI_StrRChr(buf, '\\') = '\0'; /* remove .exe file name */

    if ((cp = JLI_StrRChr(buf, '\\')) == 0) {

        /* This happens if the application is in a drive root, and

         * there is no bin directory. */

        buf[0] = '\0';

        return JNI_FALSE;

    }

    *cp = '\0';  /* remove the bin\ part */

    return JNI_TRUE;

}

/*

 * Helpers to look in the registry for a public JRE.

 */

                    /* Same for 1.5.0, 1.5.1, 1.5.2 etc. */

#define JRE_KEY     "Software\\JavaSoft\\Java Runtime Environment"

static jboolean

GetStringFromRegistry(HKEY key, const char *name, char *buf, jint bufsize)

{

    DWORD type, size;

    if (RegQueryValueEx(key, name, 0, &type, 0, &size) == 0

        && type == REG_SZ

        && (size < (unsigned int)bufsize)) {

        if (RegQueryValueEx(key, name, 0, 0, buf, &size) == 0) {

            return JNI_TRUE;

        }

    }

    return JNI_FALSE;

}

static jboolean

GetPublicJREHome(char *buf, jint bufsize)

{

    HKEY key, subkey;

    char version[MAXPATHLEN];

    /*

     * Note: There is a very similar implementation of the following

     * registry reading code in the Windows java control panel (javacp.cpl).

     * If there are bugs here, a similar bug probably exists there.  Hence,

     * changes here require inspection there.

     */

    /* Find the current version of the JRE */

    if (RegOpenKeyEx(HKEY_LOCAL_MACHINE, JRE_KEY, 0, KEY_READ, &key) != 0) {

        JLI_ReportErrorMessage(REG_ERROR1, JRE_KEY);

        return JNI_FALSE;

    }

    if (!GetStringFromRegistry(key, "CurrentVersion",

                               version, sizeof(version))) {

        JLI_ReportErrorMessage(REG_ERROR2, JRE_KEY);

        RegCloseKey(key);

        return JNI_FALSE;

    }

    if (JLI_StrCmp(version, GetDotVersion()) != 0) {

        JLI_ReportErrorMessage(REG_ERROR3, JRE_KEY, version, GetDotVersion()

        );

        RegCloseKey(key);

        return JNI_FALSE;

    }

    /* Find directory where the current version is installed. */

    if (RegOpenKeyEx(key, version, 0, KEY_READ, &subkey) != 0) {

        JLI_ReportErrorMessage(REG_ERROR1, JRE_KEY, version);

        RegCloseKey(key);

        return JNI_FALSE;

    }

    if (!GetStringFromRegistry(subkey, "JavaHome", buf, bufsize)) {

        JLI_ReportErrorMessage(REG_ERROR4, JRE_KEY, version);

        RegCloseKey(key);

        RegCloseKey(subkey);

        return JNI_FALSE;

    }

    if (JLI_IsTraceLauncher()) {

        char micro[MAXPATHLEN];

        if (!GetStringFromRegistry(subkey, "MicroVersion", micro,

                                   sizeof(micro))) {

            printf("Warning: Can't read MicroVersion\n");

            micro[0] = '\0';

        }

        printf("Version major.minor.micro = %s.%s\n", version, micro);

    }

    RegCloseKey(key);

    RegCloseKey(subkey);

    return JNI_TRUE;

}

/*

 * Support for doing cheap, accurate interval timing.

 */

static jboolean counterAvailable = JNI_FALSE;

static jboolean counterInitialized = JNI_FALSE;

static LARGE_INTEGER counterFrequency;

jlong CounterGet()

{

    LARGE_INTEGER count;

    if (!counterInitialized) {

        counterAvailable = QueryPerformanceFrequency(&counterFrequency);

        counterInitialized = JNI_TRUE;

    }

    if (!counterAvailable) {

        return 0;

    }

    QueryPerformanceCounter(&count);

    return (jlong)(count.QuadPart);

}

jlong Counter2Micros(jlong counts)

{

    if (!counterAvailable || !counterInitialized) {

        return 0;

    }

    return (counts * 1000 * 1000)/counterFrequency.QuadPart;

}

void

JLI_ReportErrorMessage(const char* fmt, ...) {

    va_list vl;

    va_start(vl,fmt);

    if (IsJavaw()) {

        char *message;

        /* get the length of the string we need */

        int n = _vscprintf(fmt, vl);

        message = (char *)JLI_MemAlloc(n + 1);

        _vsnprintf(message, n, fmt, vl);

        message[n]='\0';

        MessageBox(NULL, message, "Java Virtual Machine Launcher",

            (MB_OK|MB_ICONSTOP|MB_APPLMODAL));

        JLI_MemFree(message);

    } else {

        vfprintf(stderr, fmt, vl);

        fprintf(stderr, "\n");

    }

    va_end(vl);

}

/*

 * Just like JLI_ReportErrorMessage, except that it concatenates the system

 * error message if any, its upto the calling routine to correctly

 * format the separation of the messages.

 */

void

JLI_ReportErrorMessageSys(const char *fmt, ...)

{

    va_list vl;

    int save_errno = errno;

    DWORD       errval;