jruby-launcher 0.9.9-java

data/utilsfuncs.h

@@ -0,0 +1,84 @@
+/*
+ * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS HEADER.
+ *
+ * Copyright 2009-2010 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
+ */
+
+#ifndef _UTILSFUNCS_H
+#define _UTILSFUNCS_H
+
+#include <string>
+#include <list>
+
+bool dirExists(const char *path);
+bool fileExists(const char *path);
+void logMsg(const char *format, ...);
+void logErr(bool appendSysError, bool showMsgBox, const char *format, ...);
+bool checkLoggingArg(int argc, char *argv[], bool delFile);
+bool printToConsole(const char *msg);
+char** convertToArgvArray(std::list<std::string> args);
+void addToArgList(std::list<std::string> & args, int argc, char ** argv);
+char* findOnPath(const char* name);
+bool checkDirectory(const char* path);
+int printArgvToConsole(char** argv);
+
+#ifndef WIN32
+#define FILE_SEP '/'
+#define PATH_SEP ':'
+#else  // WIN32
+#include <windows.h>
+#define FILE_SEP '\\'
+#define PATH_SEP ';'
+
+#ifdef JRUBYW
+bool setupProcess(int &argc, char *argv[], DWORD &parentProcID, const char *attachMsg = 0);
+bool getParentProcessID(DWORD &id);
+#endif /* JRUBYW */
+
+bool normalizePath(char *path, int len);
+bool disableFolderVirtualization(HANDLE hProcess);
+char * getCurrentModulePath(char *path, int pathLen);
+bool getStringFromRegistry(HKEY rootKey, const char *keyName, const char *valueName, std::string &value);
+bool getDwordFromRegistry(HKEY rootKey, const char *keyName, const char *valueName, DWORD &value);
+bool isConsoleAttached();
+#endif  // WIN32
+
+#endif  /* _UTILSFUNCS_H */

data/utilsfuncswin.cpp

@@ -0,0 +1,229 @@
+#include "utilsfuncs.h"
+#include "argnames.h"
+#include <tlhelp32.h>
+
+using namespace std;
+
+bool normalizePath(char *path, int len) {
+    char tmp[MAX_PATH] = "";
+    int i = 0;
+    while (path[i] && i < MAX_PATH - 1) {
+        tmp[i] = path[i] == '/' ? '\\' : path[i];
+        i++;
+    }
+    tmp[i] = '\0';
+    return _fullpath(path, tmp, len) != NULL;
+}
+
+bool disableFolderVirtualization(HANDLE hProcess) {
+    OSVERSIONINFO osvi = {0};
+    osvi.dwOSVersionInfoSize = sizeof (OSVERSIONINFO);
+    if (GetVersionEx(&osvi) && osvi.dwMajorVersion == 6) // check it is Win VISTA
+    {
+        HANDLE hToken;
+        if (OpenProcessToken(hProcess, TOKEN_ALL_ACCESS, &hToken)) {
+            DWORD tokenInfoVal = 0;
+            if (!SetTokenInformation(hToken, (TOKEN_INFORMATION_CLASS) 24, &tokenInfoVal, sizeof (DWORD))) {
+                // invalid token information class (24) is OK, it means there is no folder virtualization on current system
+                if (GetLastError() != ERROR_INVALID_PARAMETER) {
+                    logErr(true, true, "Failed to set token information.");
+                    return false;
+                }
+            }
+            CloseHandle(hToken);
+        } else {
+            logErr(true, true, "Failed to open process token.");
+            return false;
+        }
+    }
+    return true;
+}
+
+bool getStringFromRegistry(HKEY rootKey, const char *keyName, const char *valueName, string &value) {
+    logMsg("getStringFromRegistry()\n\tkeyName: %s\n\tvalueName: %s", keyName, valueName);
+    HKEY hKey = 0;
+    if (RegOpenKeyEx(rootKey, keyName, 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
+        DWORD valSize = 4096;
+        DWORD type = 0;
+        char val[4096] = "";
+        if (RegQueryValueEx(hKey, valueName, 0, &type, (BYTE *) val, &valSize) == ERROR_SUCCESS
+                && type == REG_SZ) {
+            logMsg("%s: %s", valueName, val);
+            RegCloseKey(hKey);
+            value = val;
+            return true;
+        } else {
+            logErr(true, false, "RegQueryValueEx() failed.");
+        }
+        RegCloseKey(hKey);
+    } else {
+        logErr(true, false, "RegOpenKeyEx() failed.");
+    }
+    return false;
+}
+
+bool getDwordFromRegistry(HKEY rootKey, const char *keyName, const char *valueName, DWORD &value) {
+    logMsg("getDwordFromRegistry()\n\tkeyName: %s\n\tvalueName: %s", keyName, valueName);
+    HKEY hKey = 0;
+    if (RegOpenKeyEx(rootKey, keyName, 0, KEY_READ, &hKey) == ERROR_SUCCESS) {
+        DWORD valSize = sizeof(DWORD);
+        DWORD type = 0;
+        if (RegQueryValueEx(hKey, valueName, 0, &type, (BYTE *) &value, &valSize) == ERROR_SUCCESS
+                && type == REG_DWORD) {
+            logMsg("%s: %u", valueName, value);
+            RegCloseKey(hKey);
+            return true;
+        } else {
+            logErr(true, false, "RegQueryValueEx() failed.");
+        }
+        RegCloseKey(hKey);
+    } else {
+        logErr(true, false, "RegOpenKeyEx() failed.");
+    }
+    return false;
+}
+
+char * getCurrentModulePath(char *path, int pathLen) {
+    MEMORY_BASIC_INFORMATION mbi;
+    static int dummy;
+    VirtualQuery(&dummy, &mbi, sizeof (mbi));
+    HMODULE hModule = (HMODULE) mbi.AllocationBase;
+    GetModuleFileName(hModule, path, pathLen);
+    return path;
+}
+
+#ifdef JRUBYW
+bool setupProcess(int &argc, char *argv[], DWORD &parentProcID, const char *attachMsg) {
+#define CHECK_ARG \
+    if (i+1 == argc) {\
+        logErr(false, true, "Argument is missing for \"%s\" option.", argv[i]);\
+        return false;\
+    }
+
+    parentProcID = 0;
+    DWORD cmdLineArgPPID = 0;
+    for (int i = 0; i < argc; i++) {
+        // break arg parsing, once "--" is found
+        if (strcmp("--", argv[i]) == 0) {
+            break;
+        }
+        if (strcmp(ARG_NAME_CONSOLE, argv[i]) == 0) {
+            CHECK_ARG;
+            if (strcmp("new", argv[i + 1]) == 0){
+                logMsg("Allocating new console...");
+                AllocConsole();
+            } else if (strcmp("suppress", argv[i + 1]) == 0) {
+                logMsg("Suppressing the attachment to console...");
+                // nothing, no console should be attached
+            } else if (strcmp("attach", argv[i + 1]) == 0) {
+                logMsg("Trying to attach to the existing console...");
+                // attach to parent process console if exists
+                // AttachConsole exists since WinXP, so be nice and do it dynamically
+                typedef BOOL(WINAPI * LPFAC)(DWORD dwProcessId);
+                HINSTANCE hKernel32 = GetModuleHandle("kernel32");
+                if (hKernel32) {
+                    LPFAC attachConsole = (LPFAC) GetProcAddress(hKernel32, "AttachConsole");
+                    if (attachConsole) {
+                        if (cmdLineArgPPID) {
+                            if (!attachConsole(cmdLineArgPPID)) {
+                                logErr(true, false, "AttachConsole of PPID: %u failed.", cmdLineArgPPID);
+                            }
+                        } else {
+                            if (!attachConsole((DWORD) - 1)) {
+                                logErr(true, true, "AttachConsole of PP failed.");
+                            } else {
+                                getParentProcessID(parentProcID);
+                                if (attachMsg) {
+                                    printToConsole(attachMsg);
+                                }
+                            }
+                        }
+                    } else {
+                        logErr(true, false, "GetProcAddress() for AttachConsole failed.");
+                    }
+                }
+            } else {
+                logErr(false, true, "Invalid argument for \"%s\" option.", argv[i]);
+                return false;
+            }
+            // remove options
+            for (int k = i + 2; k < argc; k++) {
+                argv[k-2] = argv[k];
+            }
+            argc -= 2;
+            return true;
+        }
+    }
+#undef CHECK_ARG
+
+    return true;
+}
+#endif /* JRUBYW */
+
+bool isConsoleAttached() {
+    typedef HWND (WINAPI *GetConsoleWindowT)();
+    HINSTANCE hKernel32 = GetModuleHandle("kernel32");
+    if (hKernel32) {
+        GetConsoleWindowT getConsoleWindow = (GetConsoleWindowT) GetProcAddress(hKernel32, "GetConsoleWindow");
+        if (getConsoleWindow) {
+            if (getConsoleWindow() != NULL) {
+                logMsg("Console is attached.");
+                return true;
+            }
+        } else {
+            logErr(true, false, "GetProcAddress() for GetConsoleWindow failed.");
+        }
+    }
+    return false;
+}
+
+#ifdef JRUBYW
+bool getParentProcessID(DWORD &id) {
+    typedef HANDLE (WINAPI * CreateToolhelp32SnapshotT)(DWORD, DWORD);
+    typedef BOOL (WINAPI * Process32FirstT)(HANDLE, LPPROCESSENTRY32);
+    typedef BOOL (WINAPI * Process32NextT)(HANDLE, LPPROCESSENTRY32);
+
+    HINSTANCE hKernel32 = GetModuleHandle("kernel32");
+    if (!hKernel32) {
+        return false;
+    }
+
+    CreateToolhelp32SnapshotT createToolhelp32Snapshot = (CreateToolhelp32SnapshotT) GetProcAddress(hKernel32, "CreateToolhelp32Snapshot");
+    Process32FirstT process32First = (Process32FirstT) GetProcAddress(hKernel32, "Process32First");
+    Process32NextT process32Next = (Process32NextT) GetProcAddress(hKernel32, "Process32Next");
+
+    if (createToolhelp32Snapshot == NULL || process32First == NULL || process32Next == NULL) {
+        logErr(true, false, "Failed to obtain Toolhelp32 functions.");
+        return false;
+    }
+
+    HANDLE hSnapshot = createToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+    if (hSnapshot == INVALID_HANDLE_VALUE) {
+        logErr(true, false, "Failed to obtain process snapshot.");
+        return false;
+    }
+
+    PROCESSENTRY32 entry = {0};
+    entry.dwSize = sizeof (PROCESSENTRY32);
+    if (!process32First(hSnapshot, &entry)) {
+        CloseHandle(hSnapshot);
+        return false;
+    }
+
+    DWORD curID = GetCurrentProcessId();
+    logMsg("Current process ID: %u", curID);
+
+    do {
+        if (entry.th32ProcessID == curID) {
+            id = entry.th32ParentProcessID;
+            logMsg("Parent process ID: %u", id);
+            CloseHandle(hSnapshot);
+            return true;
+        }
+    } while (process32Next(hSnapshot, &entry));
+
+    CloseHandle(hSnapshot);
+    return false;
+}
+#endif /* JRUBYW */
+

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification 
+name: jruby-launcher
+version: !ruby/object:Gem::Version 
+  prerelease: false
+  segments: 
+    - 0
+    - 9
+    - 9
+  version: 0.9.9
+platform: java
+authors: 
+  - Nick Sieger
+  - Vladimir Sizikov
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-01 00:00:00 -06:00
+default_executable: 
+dependencies: []
+
+description: Builds and installs a native launcher for JRuby on your system
+email: 
+  - nick@nicksieger.com
+  - vsizikov@gmail.com
+executables: []
+
+extensions: 
+  - extconf.rb
+extra_rdoc_files: []
+
+files: 
+  - COPYING
+  - README.txt
+  - Makefile
+  - Rakefile
+  - ng.c
+  - strlcpy.c
+  - argparser.cpp
+  - jruby.cpp
+  - jrubyexe.cpp
+  - jvmlauncher.cpp
+  - platformlauncher.cpp
+  - unixlauncher.cpp
+  - utilsfuncs.cpp
+  - utilsfuncswin.cpp
+  - argnames.h
+  - argparser.h
+  - jvmlauncher.h
+  - nbexecloader.h
+  - platformlauncher.h
+  - rb_w32_cmdvector.h
+  - unixlauncher.h
+  - utilsfuncs.h
+  - inc/Makefile-conf.mk
+  - inc/Makefile-impl.mk
+  - inc/Makefile-rules.mk
+  - extconf.rb
+  - lib/jruby-launcher.rb
+  - lib/rubygems/defaults/jruby_native.rb
+  - spec/launcher_spec.rb
+  - spec/spec_helper.rb
+  - resources/jruby.ico
+  - resources/jruby.rc
+has_rdoc: true
+homepage: http://jruby.org
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        segments: 
+          - 0
+        version: "0"
+requirements: []
+
+rubyforge_project: jruby-extras
+rubygems_version: 1.3.6
+signing_key: 
+specification_version: 3
+summary: Native launcher for JRuby
+test_files: []
+