/*

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

 *

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

#include <sys/types.h>

#include <sys/stat.h>

#include <jni.h>

#include "java.h"

#ifndef GAMMA

#include "version_comp.h"

#endif

#define JVM_DLL "jvm.dll"

#define JAVA_DLL "java.dll"

#define CRT_DLL "msvcr71.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);

/* We supports warmup for UI stack that is performed in parallel

 * to VM initialization.

 * This helps to improve startup of UI application as warmup phase

 * might be long due to initialization of OS or hardware resources.

 * It is not CPU bound and therefore it does not interfere with VM init.

 * Obviously such warmup only has sense for UI apps and therefore it needs

 * to be explicitly requested by passing -Dsun.awt.warmup=true property

 * (this is always the case for plugin/javaws).

 *

 * Implementation launches new thread after VM starts and use it to perform

 * warmup code (platform dependent).

 * This thread is later reused as AWT toolkit thread as graphics toolkit

 * often assume that they are used from the same thread they were launched on.

 *

 * At the moment we only support warmup for D3D. It only possible on windows

 * and only if other flags do not prohibit this (e.g. OpenGL support requested).

 */

#undef ENABLE_AWT_PRELOAD

#ifndef JAVA_ARGS /* turn off AWT preloading for javac, jar, etc */

  #ifdef _X86_ /* for now disable AWT preloading for 64bit */

    #define ENABLE_AWT_PRELOAD

  #endif

#endif

#ifdef ENABLE_AWT_PRELOAD

/* "AWT was preloaded" flag;

 * Turned on by AWTPreload().

 */

int awtPreloaded = 0;

/* Calls a function with the name specified.

 * The function must be int(*fn)(void).

 */

int AWTPreload(const char *funcName);

/* Stops AWT preloading. */

void AWTPreloadStop();

/* D3D preloading */

/* -1: not initialized; 0: OFF, 1: ON */

int awtPreloadD3D = -1;

/* Command line parameter to swith D3D preloading on. */

#define PARAM_PRELOAD_D3D "-Dsun.awt.warmup"

/* D3D/OpenGL management parameters (may disable D3D preloading) */

#define PARAM_NODDRAW "-Dsun.java2d.noddraw"

#define PARAM_D3D "-Dsun.java2d.d3d"

#define PARAM_OPENGL "-Dsun.java2d.opengl"

/* funtion in awt.dll (src/windows/native/sun/java2d/d3d/D3DPipelineManager.cpp) */

#define D3D_PRELOAD_FUNC "preloadD3D"

/* Extracts value of a parameter with the specified name

 * from command line argument (returns pointer in the argument).

 * Returns NULL if the argument does not contains the parameter.

 * e.g.:

 * GetParamValue("theParam", "theParam=value") returns pointer to "value".

 */

const char * GetParamValue(const char *paramName, const char *arg) {

    int nameLen = strlen(paramName);

    if (strncmp(paramName, arg, nameLen) == 0) {

        // arg[nameLen] is valid (may contain final NULL)

        if (arg[nameLen] == '=') {

            return arg + nameLen + 1;

        }

    }

    return NULL;

}

/* Checks if commandline argument contains property specified

 * and analyze it as boolean property (true/false).

 * Returns -1 if the argument does not contain the parameter;

 * Returns 1 if the argument contains the parameter and its value is "true";

 * Returns 0 if the argument contains the parameter and its value is "false".

 */

int GetBoolParamValue(const char *paramName, const char *arg) {

    const char * paramValue = GetParamValue(paramName, arg);

    if (paramValue != NULL) {

        if (stricmp(paramValue, "true") == 0) {

            return 1;

        }

        if (stricmp(paramValue, "false") == 0) {

            return 0;

        }

    }

    return -1;

}

#endif /* ENABLE_AWT_PRELOAD */

const char *

GetArch()

{

#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) {

#ifndef GAMMA

   char * jvmtype;

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

    if (!GetJREPath(jrepath, so_jrepath)) {

        ReportErrorMessage("Error: could not find Java SE Runtime Environment.",

                           JNI_TRUE);

        exit(2);

    }

    /* Do this before we read jvm.cfg */

    EnsureJreInstallation(jrepath);

    /* Find the specified JVM type */

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

        ReportErrorMessage("Error: no known VMs. (check for corrupt jvm.cfg file)",

                           JNI_TRUE);

        exit(1);

    }

    jvmtype = CheckJvmType(_argc, _argv, JNI_FALSE);

    jvmpath[0] = '\0';

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

        char * message=NULL;

        const char * format = "Error: no `%s' JVM at `%s'.";

        message = (char *)JLI_MemAlloc((strlen(format)+strlen(jvmtype)+

                                    strlen(jvmpath)) * sizeof(char));

        sprintf(message,format, jvmtype, jvmpath);

        ReportErrorMessage(message, JNI_TRUE);

        exit(4);

    }

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

#else  /* ifndef GAMMA */

    /*

     * gamma launcher is simpler in that it doesn't handle VM flavors, data

     * model, etc. Assuming everything is set-up correctly

     * all we need to do here is to return correct path names. See also

     * GetJVMPath() and GetApplicationHome().

     */

  {

    if (!GetJREPath(jrepath, so_jrepath) ) {

       ReportErrorMessage("Error: could not find Java SE Runtime Environment.",

                          JNI_TRUE);

       exit(2);

    }

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

       char * message=NULL;

       const char * format = "Error: no JVM at `%s'.";

       message = (char *)JLI_MemAlloc((strlen(format)+

                                       strlen(jvmpath)) * sizeof(char));

       sprintf(message, format, jvmpath);

       ReportErrorMessage(message, JNI_TRUE);

       exit(4);

    }

  }

#endif  /* ifndef GAMMA */

}

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.

         */

        if (GetJREPath(crtpath, MAXPATHLEN)) {

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

            if (_launcher_debug) {

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

            }

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

                if (LoadLibrary(crtpath) == 0) {

                    ReportErrorMessage2("Error loading: %s", crtpath, JNI_TRUE);

                    return JNI_FALSE;

                }

            }

        }

        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;

    /* 32 bit windows only please */

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

        if (_launcher_debug) {

            printf("EnsureJreInstallation:unsupported platform\n");

        }

        return;

    }

    /* Does our bundle directory exist ? */

    strcpy(tmpbuf, jrepath);

    strcat(tmpbuf, "\\lib\\bundles");

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

        if (_launcher_debug) {

            printf("EnsureJreInstallation:<%s>:not found\n", tmpbuf);

        }

        return;

    }

    /* Does our jkernel dll exist ? */

    strcpy(tmpbuf, jrepath);

    strcat(tmpbuf, "\\bin\\jkernel.dll");

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

        if (_launcher_debug) {

            printf("EnsureJreInstallation:<%s>:not found\n", tmpbuf);

        }

        return;

    }

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

    if (!LoadMSVCRT()) {

        if (_launcher_debug) {

            printf("EnsureJreInstallation:could not load C runtime DLL\n");

        }

        return;

    }

    /* Load the jkernel.dll */

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

        if (_launcher_debug) {

            printf("EnsureJreInstallation:%s:load failed\n", tmpbuf);

        }

        return;

    }

    /* Get the function address */

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

    if (PreJVMStart == NULL) {

        if (_launcher_debug) {

            printf("EnsureJreInstallation:preJVMStart:function lookup failed\n");

        }

        FreeLibrary(handle);

        return;

    }

    PreJVMStart();

    if (_launcher_debug) {

        printf("EnsureJreInstallation:preJVMStart:called\n");

    }

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

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

            strcat(path, "\\jre");

            goto found;

        }

    }

#ifndef GAMMA

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

    if (GetPublicJREHome(path, pathsize)) {

        goto found;

    }

#endif

    fprintf(stderr, "Error: could not find " JAVA_DLL "\n");

    return JNI_FALSE;

 found:

    if (_launcher_debug)

      printf("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;

#ifndef GAMMA

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

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

    } else {

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

    }

#else

    /*

     * For gamma launcher, JVM is either built-in or in the same directory.

     * Either way we return "<exe_path>/jvm.dll" where <exe_path> is the

     * directory where gamma launcher is located.

     */

    char *p;

    GetModuleFileName(0, jvmpath, jvmpathsize);

    p = strrchr(jvmpath, '\\');

    if (p) {

       /* replace executable name with libjvm.so */

       snprintf(p + 1, jvmpathsize - (p + 1 - jvmpath), "%s", JVM_DLL);

    } else {

       /* this case shouldn't happen */

       snprintf(jvmpath, jvmpathsize, "%s", JVM_DLL);

    }

#endif /* ifndef GAMMA */

    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)

{

#ifdef GAMMA

    /* JVM is directly linked with gamma launcher; no Loadlibrary() */

    ifn->CreateJavaVM = JNI_CreateJavaVM;

    ifn->GetDefaultJavaVMInitArgs = JNI_GetDefaultJavaVMInitArgs;

    return JNI_TRUE;

#else

    HINSTANCE handle;

    if (_launcher_debug) {

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

    }

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

    LoadMSVCRT();

    /* Load the Java VM DLL */

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

        ReportErrorMessage2("Error loading: %s", (char *)jvmpath, JNI_TRUE);

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

        ReportErrorMessage2("Error: can't find JNI interfaces in: %s",

                            (char *)jvmpath, JNI_TRUE);

        return JNI_FALSE;

    }

    return JNI_TRUE;

#endif /* ifndef GAMMA */

}

/*

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

 */

jboolean

GetApplicationHome(char *buf, jint bufsize)

{

#ifndef GAMMA

    char *cp;

    GetModuleFileName(0, buf, bufsize);

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

    if ((cp = 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;

#else /* ifndef GAMMA */

    /* gamma launcher uses JAVA_HOME or ALT_JAVA_HOME environment variable to find JDK/JRE */

    char* java_home_var = getenv("ALT_JAVA_HOME");

    if (java_home_var == NULL) {

       java_home_var = getenv("JAVA_HOME");

    }

    if (java_home_var == NULL) {

       printf("JAVA_HOME or ALT_JAVA_HOME must point to a valid JDK/JRE to run gamma\n");

       return JNI_FALSE;

    }

    snprintf(buf, bufsize, "%s", java_home_var);

    return JNI_TRUE;

#endif /* ifndef GAMMA */

}

#ifdef JAVAW

__declspec(dllimport) char **__initenv;

int WINAPI

WinMain(HINSTANCE inst, HINSTANCE previnst, LPSTR cmdline, int cmdshow)

{

    int   ret;

    __initenv = _environ;

    ret = main(__argc, __argv);

    return ret;

}

#endif

#ifndef GAMMA

/*

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

 */

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

#define DOTRELEASE  JDK_MAJOR_VERSION "." JDK_MINOR_VERSION

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

static jboolean

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

{