jruby-launcher 0.9.9-java

data/jvmlauncher.cpp

@@ -0,0 +1,421 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * 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() {
+}
+
+bool JvmLauncher::checkJava(const char *path, const char *prefix) {
+    assert(path);
+    assert(prefix);
+    logMsg("checkJava(%s)", path);
+    javaPath = path;
+    if (*javaPath.rbegin() == '\\') {
+        javaPath.erase(javaPath.length() - 1, 1);
+    }
+    javaExePath = javaPath + prefix + JAVA_EXE_FILE;
+    javawExePath = javaPath + prefix + JAVAW_EXE_FILE;
+    javaClientDllPath = javaPath + prefix + JAVA_CLIENT_DLL_FILE;
+    javaServerDllPath = javaPath + prefix + JAVA_SERVER_DLL_FILE;
+    if (!fileExists(javaClientDllPath.c_str())) {
+        javaClientDllPath = "";
+    }
+    if (!fileExists(javaServerDllPath.c_str())) {
+        javaServerDllPath = "";
+    }
+    javaBinPath = javaPath + 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;
+        }
+        return true;
+    }
+
+    javaPath.clear();
+    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);
+    if (isVersionString(javaPathOrMinVersion)) {
+        return findJava(javaPathOrMinVersion);
+    } else {
+        return (checkJava(javaPathOrMinVersion, JAVA_JRE_PREFIX) || checkJava(javaPathOrMinVersion, ""));
+    }
+}
+
+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> args, std::list<std::string> options) {
+
+    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;
+    }
+
+    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.c_str(), prefix);
+            }
+        }
+    }
+    return false;    
+}

data/jvmlauncher.h

@@ -0,0 +1,141 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 1997-2008, 2010 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
+ */
+
+#ifndef _JVMLAUNCHER_H
+#define _JVMLAUNCHER_H
+
+#include <windows.h>
+#include <string>
+#include <list>
+#include "jni.h"
+#include "utilsfuncs.h"
+
+class JvmLauncher {
+    static const int MAX_ARGS_LEN = 32*1024;
+
+    static const char *JDK_KEY;
+    static const char *JRE_KEY;
+    static const char *CUR_VERSION_NAME;
+    static const char *JAVA_HOME_NAME;
+    static const char *JAVA_BIN_DIR;
+    static const char *JAVA_EXE_FILE;
+    static const char *JAVAW_EXE_FILE;
+    static const char *JAVA_CLIENT_DLL_FILE;
+    static const char *JAVA_SERVER_DLL_FILE;
+    static const char *JAVA_JRE_PREFIX;
+    static const char *JNI_CREATEVM_FUNC;
+
+public:
+    JvmLauncher();
+    virtual ~JvmLauncher();
+
+    bool initialize(const char *javaPathOrMinVersion);
+    bool getJavaPath(std::string &path);
+    bool start(const char *mainClassName, std::list<std::string> args, std::list<std::string> options, bool &separateProcess, DWORD *retCode);
+
+    void setSuppressConsole(bool val) {
+        suppressConsole = val;
+    }
+
+private:
+    JvmLauncher(const JvmLauncher& orig);
+
+    bool checkJava(const char *javaPath, const char *prefix);
+    bool findJava(const char *minJavaVersion);
+    bool findJava(const char *javaKey, const char *prefix, const char *minJavaVersion);
+    bool startOutProcJvm(const char *mainClassName, std::list<std::string> args, std::list<std::string> options, DWORD *retCode);
+    bool startInProcJvm(const char *mainClassName, std::list<std::string> args, std::list<std::string> options);
+    bool isVersionString(const char *str);
+    bool canLoadJavaDll();
+    bool findServerOption(std::list<std::string> &options);
+
+private:
+    bool suppressConsole;
+    std::string javaExePath;
+    std::string javawExePath;
+    std::string javaDllPath;
+    std::string javaClientDllPath;
+    std::string javaServerDllPath;
+    std::string javaPath;
+    std::string javaBinPath;
+
+    class PrepareDllPath {
+    public:
+        PrepareDllPath(const char *dllDirectory)
+            : setDllDirectory(0) {
+            logMsg("PrepareDllPath: %s", dllDirectory);
+            oldCurDir[0] = '\0';
+
+            // SetDllDirectory is present since XP SP1, so we have to load it dynamically
+            HINSTANCE hKernel32 = GetModuleHandle("kernel32");
+            if (!hKernel32) {
+                logErr(true, false, "Cannot load kernel32.");
+                return;
+            }
+
+            LPFNSDD setDllDirectory = (LPFNSDD)GetProcAddress(hKernel32, "SetDllDirectoryA");
+            if (setDllDirectory) {
+                setDllDirectory(dllDirectory);
+            } else {
+                logErr(true, false, "Cannot find SetDllDirectoryA");
+            }
+            GetCurrentDirectory(MAX_PATH, oldCurDir);
+            SetCurrentDirectory(dllDirectory);
+        }
+        ~PrepareDllPath() {
+            if (setDllDirectory) {
+                setDllDirectory(NULL);
+            }
+            if (oldCurDir[0]) {
+                SetCurrentDirectory(oldCurDir);
+            }
+        }
+    private:
+        typedef BOOL (WINAPI *LPFNSDD)(LPCTSTR lpPathname);
+        LPFNSDD setDllDirectory;
+        char oldCurDir[MAX_PATH];
+    };
+};
+
+#endif  /* _JVMLAUNCHER_H */
+