/*

 * Copyright 1997-2008 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.

 */

#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 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 *_argc,

                           char ***_argv,

                           char jrepath[],

                           jint so_jrepath,

                           char jvmpath[],

                           jint so_jvmpath,

                           char **original_argv) {

    char * jvmtype;

    int i = 0;

    char** pargv = *_argv;

    int running = CURRENT_DATA_MODEL;

    int wanted = running;

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

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

            wanted = 64;

            continue;

        }

        if (JLI_StrCmp(pargv[i], "-J-d32") == 0 || JLI_StrCmp(pargv[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);

    }

    /* Find the specified JVM type */

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

        JLI_ReportErrorMessage(CFG_ERROR7);

        exit(1);

    }

    jvmtype = CheckJvmType(_argc, _argv, JNI_FALSE);

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

}

/*

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

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

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

            goto found;

        }

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

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

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

            JLI_StrCat(path, "\\jre");

            goto found;

        }

    }

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

    if (GetPublicJREHome(path, pathsize)) {

        goto found;

    }

    JLI_ReportErrorMessage(JRE_ERROR8 JAVA_DLL);

    return JNI_FALSE;

 found:

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

    return JNI_TRUE;

}

/*

 * 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, '\\')) {

        sprintf(jvmpath, "%s\\" JVM_DLL, jvmtype);

    } else {

        sprintf(jvmpath, "%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;

    char crtpath[MAXPATHLEN];

    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.

     */

    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;

            }

        }

    }

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

    jboolean freeit = JNI_FALSE;

    char  *errtext = NULL;

    va_start(vl, fmt);

    if ((errval = GetLastError()) != 0) {               /* Platform SDK / DOS Error */

        int n = FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM|

            FORMAT_MESSAGE_IGNORE_INSERTS|FORMAT_MESSAGE_ALLOCATE_BUFFER,

            NULL, errval, 0, (LPTSTR)&errtext, 0, NULL);

        if (errtext == NULL || n == 0) {                /* Paranoia check */

            errtext = "";

            n = 0;

        } else {

            freeit = JNI_TRUE;

            if (n > 2) {                                /* Drop final CR, LF */

                if (errtext[n - 1] == '\n') n--;

                if (errtext[n - 1] == '\r') n--;

                errtext[n] = '\0';

            }

        }

    } else {   /* C runtime error that has no corresponding DOS error code */

        errtext = strerror(save_errno);

    }

    if (IsJavaw()) {

        char *message;

        int mlen;

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

        int len = mlen =  _vscprintf(fmt, vl) + 1;

        if (freeit) {

           mlen += JLI_StrLen(errtext);

        }

        message = (char *)JLI_MemAlloc(mlen);

        _vsnprintf(message, len, fmt, vl);

        message[len]='\0';

        if (freeit) {

           JLI_StrCat(message, errtext);

        }

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

            (MB_OK|MB_ICONSTOP|MB_APPLMODAL));

        JLI_MemFree(message);

    } else {

        vfprintf(stderr, fmt, vl);

        if (freeit) {

           fprintf(stderr, "%s", errtext);

        }

    }

    if (freeit) {

        (void)LocalFree((HLOCAL)errtext);

    }

    va_end(vl);

}

void  JLI_ReportExceptionDescription(JNIEnv * env) {

    if (IsJavaw()) {

       /*

        * This code should be replaced by code which opens a window with

        * the exception detail message, for now atleast put a dialog up.

        */

        MessageBox(NULL, "A Java Exception has occurred.", "Java Virtual Machine Launcher",

               (MB_OK|MB_ICONSTOP|MB_APPLMODAL));

    } else {

        (*env)->ExceptionDescribe(env);

    }

}

jboolean

ServerClassMachine() {

    return (GetErgoPolicy() == ALWAYS_SERVER_CLASS) ? JNI_TRUE : JNI_FALSE;

}

/*

 * Determine if there is an acceptable JRE in the registry directory top_key.

 * Upon locating the "best" one, return a fully qualified path to it.

 * "Best" is defined as the most advanced JRE meeting the constraints

 * contained in the manifest_info. If no JRE in this directory meets the

 * constraints, return NULL.

 *

 * It doesn't matter if we get an error reading the registry, or we just

 * don't find anything interesting in the directory.  We just return NULL

 * in either case.

 */

static char *

ProcessDir(manifest_info* info, HKEY top_key) {

    DWORD   index = 0;

    HKEY    ver_key;

    char    name[MAXNAMELEN];

    int     len;

    char    *best = NULL;

    /*

     * Enumerate "<top_key>/SOFTWARE/JavaSoft/Java Runtime Environment"

     * searching for the best available version.

     */

    while (RegEnumKey(top_key, index, name, MAXNAMELEN) == ERROR_SUCCESS) {

        index++;

        if (JLI_AcceptableRelease(name, info->jre_version))

            if ((best == NULL) || (JLI_ExactVersionId(name, best) > 0)) {

                if (best != NULL)

                    JLI_MemFree(best);

                best = JLI_StringDup(name);

            }

    }