/*

* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.

*

* Copyright 2009-2012 JRuby Team (www.jruby.org).

* Copyright 1997-2008 Sun Microsystems, Inc. All rights reserved.

*

* The contents of this file are subject to the terms of either the GNU

* General Public License Version 2 only ("GPL") or the Common

* Development and Distribution License("CDDL") (collectively, the

* "License"). You may not use this file except in compliance with the

* License. You can obtain a copy of the License at

* http://www.netbeans.org/cddl-gplv2.html

* or nbbuild/licenses/CDDL-GPL-2-CP. See the License for the

* specific language governing permissions and limitations under the

* License. When distributing the software, include this License Header

* Notice in each file and include the License file at

* nbbuild/licenses/CDDL-GPL-2-CP. Sun designates this

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

* by Sun in the GPL Version 2 section of the License file that

* accompanied this code. If applicable, add the following below the

* License Header, with the fields enclosed by brackets [] replaced by

* your own identifying information:

* "Portions Copyrighted [year] [name of copyright owner]"

*

* Contributor(s):

*

* The Original Software is NetBeans. The Initial Developer of the Original

* Software is Sun Microsystems, Inc. Portions Copyright 1997-2008 Sun

* Microsystems, Inc. All Rights Reserved.

*

* If you wish your version of this file to be governed by only the CDDL

* or only the GPL Version 2, indicate your decision by adding

* "[Contributor] elects to include this software in this distribution

* under the [CDDL or GPL Version 2] license." If you do not indicate a

* single choice of license, a recipient has the option to distribute

* your version of this file under either the CDDL, the GPL Version 2 or

* to extend the choice of license to its licensees as provided above.

* However, if you add GPL Version 2 code and therefore, elected the GPL

* Version 2 license, then the option applies only if the new code is

* made subject to such option by the copyright holder.

*

* Author: Tomas Holy

*/

#include "jvmlauncher.h"

#include <cassert>

using namespace std;

const char *JvmLauncher::JDK_KEY = "Software\\JavaSoft\\Java Development Kit";

const char *JvmLauncher::JRE_KEY = "Software\\JavaSoft\\Java Runtime Environment";

const char *JvmLauncher::CUR_VERSION_NAME = "CurrentVersion";

const char *JvmLauncher::JAVA_HOME_NAME = "JavaHome";

const char *JvmLauncher::JAVA_BIN_DIR = "\\bin";

const char *JvmLauncher::JAVA_EXE_FILE = "\\bin\\java.exe";

const char *JvmLauncher::JAVAW_EXE_FILE = "\\bin\\javaw.exe";

const char *JvmLauncher::JAVA_CLIENT_DLL_FILE = "\\bin\\client\\jvm.dll";

const char *JvmLauncher::JAVA_SERVER_DLL_FILE = "\\bin\\server\\jvm.dll";

const char *JvmLauncher::JAVA_JRE_PREFIX = "\\jre";

const char *JvmLauncher::JNI_CREATEVM_FUNC = "JNI_CreateJavaVM";

JvmLauncher::JvmLauncher()

: suppressConsole(false) {

}

JvmLauncher::JvmLauncher(const JvmLauncher& orig) {

}

JvmLauncher::~JvmLauncher() {

}

void JvmLauncher::setJavaCmd(const string cmdPath) {

javaExePath = cmdPath;

javaPath = "";

javawExePath = javaPath;

javaClientDllPath = javaPath;

javaServerDllPath = javaPath;

}

bool JvmLauncher::checkJava(std::string &path, const char *prefix) {

assert(prefix);

logMsg("checkJava('%s', '%s')", path.c_str(), prefix);

if (*path.rbegin() == '\\') {

path.erase(path.length() - 1, 1);

}

javaExePath = path + prefix + JAVA_EXE_FILE;

javawExePath = path + prefix + JAVAW_EXE_FILE;

javaClientDllPath = path + prefix + JAVA_CLIENT_DLL_FILE;

javaServerDllPath = path + prefix + JAVA_SERVER_DLL_FILE;

if (!fileExists(javaClientDllPath.c_str())) {

javaClientDllPath = "";

}

if (!fileExists(javaServerDllPath.c_str())) {

javaServerDllPath = "";

}

javaBinPath = path + prefix + JAVA_BIN_DIR;

if (fileExists(javaExePath.c_str()) || !javaClientDllPath.empty() || !javaServerDllPath.empty()) {

if (!fileExists(javawExePath.c_str())) {

logMsg("javaw.exe not exists, forcing java.exe");

javawExePath = javaExePath;

}

javaPath = path;

return true;

}

javaBinPath.clear();

javaExePath.clear();

javawExePath.clear();

javaClientDllPath.clear();

javaServerDllPath.clear();

return false;

}

bool JvmLauncher::initialize(const char *javaPathOrMinVersion) {

logMsg("JvmLauncher::initialize()\n\tjavaPathOrMinVersion: %s", javaPathOrMinVersion);

assert(javaPathOrMinVersion);

std::string pathOrVersion(javaPathOrMinVersion);

if (isVersionString(javaPathOrMinVersion)) {

return findJava(javaPathOrMinVersion);

} else {

return (checkJava(pathOrVersion, JAVA_JRE_PREFIX) || checkJava(pathOrVersion, ""));

}

}

bool JvmLauncher::getJavaPath(string &path) {

logMsg("JvmLauncher::getJavaPath()");

path = javaPath;

return !javaPath.empty();

}

bool JvmLauncher::start(const char *mainClassName, list<string> args, list<string> options, bool &separateProcess, DWORD *retCode) {

assert(mainClassName);

logMsg("JvmLauncher::start()\n\tmainClassName: %s\n\tseparateProcess: %s",

mainClassName, separateProcess ? "true" : "false");

logMsg(" args:");

for (list<string>::iterator it = args.begin(); it != args.end(); ++it) {

logMsg("\t%s", it->c_str());

}

logMsg(" options:");

for (list<string>::iterator it = options.begin(); it != options.end(); ++it) {

logMsg("\t%s", it->c_str());

}

if (javaExePath.empty() && javaClientDllPath.empty() && javaServerDllPath.empty()) {

// try to find out any java installed (check the registry)

if (!initialize("")) {

return false;

}

}

if (!separateProcess) {

// both client/server found, check option which should be used

if (!javaClientDllPath.empty() && !javaServerDllPath.empty()) {

// By default, load client VM. Load server VM only if explicitly asked.

javaDllPath = findServerOption(options) ? javaServerDllPath: javaClientDllPath;

} else {

javaDllPath = javaClientDllPath.empty() ? javaServerDllPath : javaClientDllPath;

}

// it is necessary to absolutize dll path because current dir has to be

// temporarily changed for dll loading

char absoluteJavaDllPath[MAX_PATH] = "";

strncpy(absoluteJavaDllPath, javaDllPath.c_str(), MAX_PATH);

normalizePath(absoluteJavaDllPath, MAX_PATH);

javaDllPath = absoluteJavaDllPath;

logMsg("Java DLL path: %s", javaDllPath.c_str());

if (!canLoadJavaDll()) {

logMsg("Falling back to running Java in a separate process; DLL cannot be loaded (64-bit DLL?).");

separateProcess = true;

}

}

return separateProcess ? startOutProcJvm(mainClassName, args, options, retCode)

: startInProcJvm(mainClassName, args, options);

}

bool JvmLauncher::findServerOption(list<string> &options) {

for (list<string>::iterator it = options.begin(); it != options.end(); ++it) {

if (*it == "-server") {

return true;

}

}

return false;

}

bool JvmLauncher::canLoadJavaDll() {

// be prepared for stupid placement of msvcr71.dll in java installation

// (in java 1.6/1.7 jvm.dll is dynamically linked to msvcr71.dll which si placed

// in bin directory)

PrepareDllPath prepare(javaBinPath.c_str());

HMODULE hDll = LoadLibrary(javaDllPath.c_str());

if (hDll) {

FreeLibrary(hDll);

return true;

}

logErr(true, false, "Cannot load %s.", javaDllPath.c_str());

return false;

}

bool JvmLauncher::isVersionString(const char *str) {

char *end = 0;

strtod(str, &end);

return *end == '\0';

}

bool JvmLauncher::startInProcJvm(const char *mainClassName, std::list<std::string> mbcs_args, std::list<std::string> mbcs_options) {

std::list<std::string> args;

for (std::list<std::string>::iterator it = mbcs_args.begin(); it != mbcs_args.end(); ++it) {

wchar_t wstr[2048];

UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

MultiByteToWideChar(cp, 0, it->c_str(), -1, wstr, sizeof(wstr) / sizeof(wchar_t));

int mb_size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);

char *mbstr = (char*)malloc(mb_size);

WideCharToMultiByte(CP_UTF8, 0, wstr, -1, mbstr, mb_size, NULL, NULL);

args.push_back(mbstr);

}

std::list<std::string> options;

for (std::list<std::string>::iterator it = mbcs_options.begin(); it != mbcs_options.end(); ++it) {

wchar_t wstr[2048];

UINT cp = AreFileApisANSI() ? CP_ACP : CP_OEMCP;

MultiByteToWideChar(cp, 0, it->c_str(), -1, wstr, sizeof(wstr) / sizeof(wchar_t));

int mb_size = WideCharToMultiByte(CP_UTF8, 0, wstr, -1, NULL, 0, NULL, NULL);

char *mbstr = (char*)malloc(mb_size);

WideCharToMultiByte(CP_UTF8, 0, wstr, -1, mbstr, mb_size, NULL, NULL);

options.push_back(mbstr);

}

class Jvm {

public:

Jvm(JvmLauncher *jvmLauncher)

: hDll(0)

, jvm(0)

, env(0)

, jvmOptions(0)

, jvmLauncher(jvmLauncher)

{

}

~Jvm() {

if (env && env->ExceptionOccurred()) {

env->ExceptionDescribe();

}

if (jvm) {

logMsg("Destroying JVM");

jvm->DestroyJavaVM();

}

if (jvmOptions) {

delete[] jvmOptions;

}

if (hDll) {

FreeLibrary(hDll);

}

}

bool init(list<string> options) {

logMsg("JvmLauncher::Jvm::init()");

logMsg("LoadLibrary(\"%s\")", jvmLauncher->javaDllPath.c_str());

{

PrepareDllPath prepare(jvmLauncher->javaBinPath.c_str());

hDll = LoadLibrary(jvmLauncher->javaDllPath.c_str());

if (!hDll) {

logErr(true, true, "Cannot load %s.", jvmLauncher->javaDllPath.c_str());

return false;

}

}

CreateJavaVM createJavaVM = (CreateJavaVM) GetProcAddress(hDll, JNI_CREATEVM_FUNC);

if (!createJavaVM) {

logErr(true, true, "GetProcAddress for %s failed.", JNI_CREATEVM_FUNC);

return false;

}

// Explicity remove -server and -client options, they are not

// needed, since we invoke JVM in-process and already know

// which DLL to use.

options.remove("-server");

options.remove("-client");

logMsg("JVM options:");

jvmOptions = new JavaVMOption[options.size()];

int i = 0;

for (list<string>::iterator it = options.begin(); it != options.end(); ++it, ++i) {

string &option = *it;

logMsg("\t%s", option.c_str());

jvmOptions[i].optionString = (char *) option.c_str();

jvmOptions[i].extraInfo = 0;

}

JavaVMInitArgs jvmArgs;

jvmArgs.options = jvmOptions;

jvmArgs.nOptions = options.size();

jvmArgs.version = JNI_VERSION_1_4;

jvmArgs.ignoreUnrecognized = JNI_FALSE;

logMsg("Creating JVM...");

if (createJavaVM(&jvm, &env, &jvmArgs) < 0) {

logErr(false, true, "JVM creation failed");

return false;

}

logMsg("JVM created.");

return true;

}

typedef jint (CALLBACK *CreateJavaVM)(JavaVM **jvm, JNIEnv **env, void *args);

HMODULE hDll;

JavaVM *jvm;

JNIEnv *env;

JavaVMOption *jvmOptions;

JvmLauncher *jvmLauncher;

};

Jvm jvm(this);

if (!jvm.init(options)) {

return false;

}

jclass mainClass = jvm.env->FindClass(mainClassName);

if (!mainClass) {

logErr(false, true, "Cannot find class %s.", mainClassName);

return false;

}

jmethodID mainMethod = jvm.env->GetStaticMethodID(mainClass, "main", "([Ljava/lang/String;)V");

if (!mainMethod) {

logErr(false, true, "Cannot get main method.");

return false;

}

jclass jclassString = jvm.env->FindClass("java/lang/String");

if (!jclassString) {

logErr(false, true, "Cannot find java/lang/String class");

return false;

}

jstring jstringArg = jvm.env->NewStringUTF("");

if (!jstringArg) {

logErr(false, true, "NewStringUTF() failed");

return false;

}

jobjectArray mainArgs = jvm.env->NewObjectArray(args.size(), jclassString, jstringArg);

if (!mainArgs) {

logErr(false, true, "NewObjectArray() failed");

return false;

}

int i = 0;

for (list<string>::iterator it = args.begin(); it != args.end(); ++it, ++i) {

string &arg = *it;

jstring jstringArg = jvm.env->NewStringUTF(arg.c_str());

if (!jstringArg) {

logErr(false, true, "NewStringUTF() failed");

return false;

}

jvm.env->SetObjectArrayElement(mainArgs, i, jstringArg);

}

jvm.env->CallStaticVoidMethod(mainClass, mainMethod, mainArgs);

return true;

}

bool JvmLauncher::startOutProcJvm(const char *mainClassName, std::list<std::string> args, std::list<std::string> options, DWORD *retCode) {

string cmdLine = '\"' + (suppressConsole ? javawExePath : javaExePath) + '\"';

cmdLine.reserve(32*1024);

for (list<string>::iterator it = options.begin(); it != options.end(); ++it) {

cmdLine += " \"";

cmdLine += *it;

cmdLine += "\"";

}

// mainClass and args

cmdLine += ' ';

cmdLine += mainClassName;

for (list<string>::iterator it = args.begin(); it != args.end(); ++it) {

if (javaClientDllPath.empty() && *it == "-client") {

logMsg("Removing -client option, client java dll not found.");

// remove client parameter, no client java found

continue;

}

cmdLine += " \"";

cmdLine += *it;

cmdLine += "\"";

}

logMsg("Command line:\n%s", cmdLine.c_str());

if (cmdLine.size() >= 32*1024) {

logErr(false, true, "Command line is too long. Length: %u. Maximum length: %u.", cmdLine.c_str(), 32*1024);

return false;

}

STARTUPINFO si = {0};

si.cb = sizeof (STARTUPINFO);

PROCESS_INFORMATION pi = {0};

char cmdLineStr[32*1024] = "";

strcpy(cmdLineStr, cmdLine.c_str());

if (!CreateProcess(NULL, cmdLineStr, NULL, NULL, TRUE, CREATE_SUSPENDED, NULL, NULL, &si, &pi)) {

logErr(true, true, "Failed to create process");

return false;

}

// disable Ctrl-C handling in the parent process

if (!SetConsoleCtrlHandler(NULL, TRUE)) {

logErr(true, true, "Failed to disable Ctrl-C handling; Ctrl-C may behave oddly: %d", GetLastError());

}

disableFolderVirtualization(pi.hProcess);

ResumeThread(pi.hThread);

WaitForSingleObject(pi.hProcess, INFINITE);

if (retCode) {

GetExitCodeProcess(pi.hProcess, retCode);

}

CloseHandle(pi.hProcess);

CloseHandle(pi.hThread);

return true;

}

bool JvmLauncher::findJava(const char *minJavaVersion) {

if (findJava(JDK_KEY, JAVA_JRE_PREFIX, minJavaVersion)) {

return true;

}

if (findJava(JRE_KEY, "", minJavaVersion)) {

return true;

}

javaPath = "";

javaExePath = "";

javaClientDllPath = "";

javaServerDllPath = "";

javaBinPath = "";

return false;

}

bool JvmLauncher::findJava(const char *javaKey, const char *prefix, const char *minJavaVersion) {

logMsg("JvmLauncher::findJava()\n\tjavaKey: %s\n\tprefix: %s\n\tminJavaVersion: %s", javaKey, prefix, minJavaVersion);

string value;

if (getStringFromRegistry(HKEY_LOCAL_MACHINE, javaKey, CUR_VERSION_NAME, value)) {

if (value >= minJavaVersion) {

string path;

if (getStringFromRegistry(HKEY_LOCAL_MACHINE, (string(javaKey) + "\\" + value).c_str(), JAVA_HOME_NAME, path)) {

if (*path.rbegin() == '\\') {

path.erase(path.length() - 1, 1);

}

return checkJava(path, prefix);

}

}

}

return false;

}