/* * Copyright (C) 2011 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #ifdef _WIN32 // Indicate we want at least all Windows Server 2003 (5.2) APIs. // Note: default is set by system/core/include/arch/windows/AndroidConfig.h to 0x0500 // which is Win2K. However our minimum SDK tools requirement is Win XP (0x0501). // However we do need 0x0502 to get access to the WOW-64-32 constants for the // registry, except we'll need to be careful since they are not available on XP. #undef _WIN32_WINNT #define _WIN32_WINNT 0x0502 // Indicate we want at least all IE 5 shell APIs #define _WIN32_IE 0x0500 #include "find_java.h" #include <shlobj.h> #include <ctype.h> // Define some types missing in MingW #ifndef LSTATUS typedef LONG LSTATUS; #endif // Extract the first thing that looks like (digit.digit+). // Note: this will break when java reports a version with major > 9. // However it will reasonably cope with "1.10", if that ever happens. static bool extractJavaVersion(const char *start, int length, CString *outVersionStr, int *outVersionInt) { const char *end = start + length; for (const char *c = start; c < end - 2; c++) { if (isdigit(c[0]) && c[1] == '.' && isdigit(c[2])) { const char *e = c+2; while (isdigit(e[1])) { e++; } if (outVersionStr != NULL) { outVersionStr->set(c, e - c + 1); } if (outVersionInt != NULL) { // add major * 1000, currently only 1 digit int value = (*c - '0') * 1000; // add minor for (int m = 1; *e != '.'; e--, m *= 10) { value += (*e - '0') * m; } *outVersionInt = value; } return true; } } return false; } // Check whether we can find $PATH/java.exe. // inOutPath should be the directory where we're looking at. // In output, it will be the java path we tested. // Returns the java version integer found (e.g. 1006 for 1.6). // Return 0 in case of error. static int checkPath(CPath *inOutPath) { inOutPath->addPath("java.exe"); int result = 0; PVOID oldWow64Value = disableWow64FsRedirection(); if (inOutPath->fileExists()) { // Run java -version // Reject the version if it's not at least our current minimum. if (!getJavaVersion(*inOutPath, NULL /*versionStr*/, &result)) { result = 0; } } revertWow64FsRedirection(oldWow64Value); return result; } // Check whether we can find $PATH/bin/java.exe // Returns the Java version found (e.g. 1006 for 1.6) or 0 in case of error. static int checkBinPath(CPath *inOutPath) { inOutPath->addPath("bin"); return checkPath(inOutPath); } // Search java.exe in the environment int findJavaInEnvPath(CPath *outJavaPath) { SetLastError(0); int currVersion = 0; const char* envPath = getenv("JAVA_HOME"); if (envPath != NULL) { CPath p(envPath); currVersion = checkBinPath(&p); if (currVersion > 0) { if (gIsDebug) { fprintf(stderr, "Java %d found via JAVA_HOME: %s\n", currVersion, p.cstr()); } *outJavaPath = p; } if (currVersion >= MIN_JAVA_VERSION) { // As an optimization for runtime, if we find a suitable java // version in JAVA_HOME we won't waste time looking at the PATH. return currVersion; } } envPath = getenv("PATH"); if (!envPath) return currVersion; // Otherwise look at the entries in the current path. // If we find more than one, keep the one with the highest version. CArray<CString> *paths = CString(envPath).split(';'); for(int i = 0; i < paths->size(); i++) { CPath p((*paths)[i].cstr()); int v = checkPath(&p); if (v > currVersion) { if (gIsDebug) { fprintf(stderr, "Java %d found via env PATH: %s\n", v, p.cstr()); } currVersion = v; *outJavaPath = p; } } delete paths; return currVersion; } // -------------- static bool getRegValue(const char *keyPath, const char *keyName, REGSAM access, CString *outValue) { HKEY key; LSTATUS status = RegOpenKeyExA( HKEY_LOCAL_MACHINE, // hKey keyPath, // lpSubKey 0, // ulOptions KEY_READ | access, // samDesired, &key); // phkResult if (status == ERROR_SUCCESS) { LSTATUS ret = ERROR_MORE_DATA; DWORD size = 4096; // MAX_PATH is 260, so 4 KB should be good enough char* buffer = (char*) malloc(size); while (ret == ERROR_MORE_DATA && size < (1<<16) /*64 KB*/) { ret = RegQueryValueExA( key, // hKey keyName, // lpValueName NULL, // lpReserved NULL, // lpType (LPBYTE) buffer, // lpData &size); // lpcbData if (ret == ERROR_MORE_DATA) { size *= 2; buffer = (char*) realloc(buffer, size); } else { buffer[size] = 0; } } if (ret != ERROR_MORE_DATA) outValue->set(buffer); free(buffer); RegCloseKey(key); return (ret != ERROR_MORE_DATA); } return false; } // Explore the registry to find a suitable version of Java. // Returns an int which is the version of Java found (e.g. 1006 for 1.6) and the // matching path in outJavaPath. // Returns 0 if nothing suitable was found. static int exploreJavaRegistry(const char *entry, REGSAM access, CPath *outJavaPath) { // Let's visit HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment [CurrentVersion] CPath rootKey("SOFTWARE\\JavaSoft\\"); rootKey.addPath(entry); int versionInt = 0; CString currentVersion; CPath subKey(rootKey); if (getRegValue(subKey.cstr(), "CurrentVersion", access, ¤tVersion)) { // CurrentVersion should be something like "1.7". // We want to read HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment\1.7 [JavaHome] subKey.addPath(currentVersion); CPath javaHome; if (getRegValue(subKey.cstr(), "JavaHome", access, &javaHome)) { versionInt = checkBinPath(&javaHome); if (versionInt >= 0) { if (gIsDebug) { fprintf(stderr, "Java %d found via registry: %s\n", versionInt, javaHome.cstr()); } *outJavaPath = javaHome; } if (versionInt >= MIN_JAVA_VERSION) { // Heuristic: if the current version is good enough, stop here return versionInt; } } } // Try again, but this time look at all the versions available HKEY javaHomeKey; LSTATUS status = RegOpenKeyExA( HKEY_LOCAL_MACHINE, // hKey "SOFTWARE\\JavaSoft", // lpSubKey 0, // ulOptions KEY_READ | access, // samDesired &javaHomeKey); // phkResult if (status == ERROR_SUCCESS) { char name[256]; DWORD index = 0; CPath javaHome; for (LONG result = ERROR_SUCCESS; result == ERROR_SUCCESS; index++) { DWORD nameLen = 255; name[nameLen] = 0; result = RegEnumKeyExA( javaHomeKey, // hKey index, // dwIndex name, // lpName &nameLen, // lpcName NULL, // lpReserved NULL, // lpClass NULL, // lpcClass, NULL); // lpftLastWriteTime if (result == ERROR_SUCCESS && nameLen < 256) { name[nameLen] = 0; CPath subKey(rootKey); subKey.addPath(name); if (getRegValue(subKey.cstr(), "JavaHome", access, &javaHome)) { int v = checkBinPath(&javaHome); if (v > versionInt) { if (gIsDebug) { fprintf(stderr, "Java %d found via registry: %s\n", versionInt, javaHome.cstr()); } *outJavaPath = javaHome; versionInt = v; } } } } RegCloseKey(javaHomeKey); } return 0; } static bool getMaxJavaInRegistry(const char *entry, REGSAM access, CPath *outJavaPath, int *inOutVersion) { CPath path; int version = exploreJavaRegistry(entry, access, &path); if (version > *inOutVersion) { *outJavaPath = path; *inOutVersion = version; return true; } return false; } int findJavaInRegistry(CPath *outJavaPath) { // We'll do the registry test 3 times: first using the default mode, // then forcing the use of the 32-bit registry then forcing the use of // 64-bit registry. On Windows 2k, the 2 latter will fail since the // flags are not supported. On a 32-bit OS the 64-bit is obviously // useless and the 2 first tests should be equivalent so we just // need the first case. // Check the JRE first, then the JDK. int version = MIN_JAVA_VERSION - 1; bool result = false; result |= getMaxJavaInRegistry("Java Runtime Environment", 0, outJavaPath, &version); result |= getMaxJavaInRegistry("Java Development Kit", 0, outJavaPath, &version); // Get the app sysinfo state (the one hidden by WOW64) SYSTEM_INFO sysInfo; GetSystemInfo(&sysInfo); WORD programArch = sysInfo.wProcessorArchitecture; // Check the real sysinfo state (not the one hidden by WOW64) for x86 GetNativeSystemInfo(&sysInfo); WORD actualArch = sysInfo.wProcessorArchitecture; // Only try to access the WOW64-32 redirected keys on a 64-bit system. // There's no point in doing this on a 32-bit system. if (actualArch == PROCESSOR_ARCHITECTURE_AMD64) { if (programArch != PROCESSOR_ARCHITECTURE_INTEL) { // If we did the 32-bit case earlier, don't do it twice. result |= getMaxJavaInRegistry( "Java Runtime Environment", KEY_WOW64_32KEY, outJavaPath, &version); result |= getMaxJavaInRegistry( "Java Development Kit", KEY_WOW64_32KEY, outJavaPath, &version); } else if (programArch != PROCESSOR_ARCHITECTURE_AMD64) { // If we did the 64-bit case earlier, don't do it twice. result |= getMaxJavaInRegistry( "Java Runtime Environment", KEY_WOW64_64KEY, outJavaPath, &version); result |= getMaxJavaInRegistry( "Java Development Kit", KEY_WOW64_64KEY, outJavaPath, &version); } } return result ? version : 0; } // -------------- static bool checkProgramFiles(CPath *outJavaPath, int *inOutVersion) { char programFilesPath[MAX_PATH + 1]; HRESULT result = SHGetFolderPathA( NULL, // hwndOwner CSIDL_PROGRAM_FILES, // nFolder NULL, // hToken SHGFP_TYPE_CURRENT, // dwFlags programFilesPath); // pszPath if (FAILED(result)) return false; CPath path(programFilesPath); path.addPath("Java"); // Do we have a C:\\Program Files\\Java directory? if (!path.dirExists()) return false; CPath glob(path); glob.addPath("j*"); bool found = false; WIN32_FIND_DATAA findData; HANDLE findH = FindFirstFileA(glob.cstr(), &findData); if (findH == INVALID_HANDLE_VALUE) return false; do { if ((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) { CPath temp(path); temp.addPath(findData.cFileName); // Check C:\\Program Files[x86]\\Java\\j*\\bin\\java.exe int v = checkBinPath(&temp); if (v > *inOutVersion) { found = true; *inOutVersion = v; *outJavaPath = temp; } } } while (!found && FindNextFileA(findH, &findData) != 0); FindClose(findH); return found; } int findJavaInProgramFiles(CPath *outJavaPath) { // Check the C:\\Program Files (x86) directory // With WOW64 fs redirection in place by default, we should get the x86 // version on a 64-bit OS since this app is a 32-bit itself. bool result = false; int version = MIN_JAVA_VERSION - 1; result |= checkProgramFiles(outJavaPath, &version); // Check the real sysinfo state (not the one hidden by WOW64) for x86 SYSTEM_INFO sysInfo; GetNativeSystemInfo(&sysInfo); if (sysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) { // On a 64-bit OS, try again by disabling the fs redirection so // that we can try the real C:\\Program Files directory. PVOID oldWow64Value = disableWow64FsRedirection(); result |= checkProgramFiles(outJavaPath, &version); revertWow64FsRedirection(oldWow64Value); } return result ? version : 0; } // -------------- // Tries to invoke the java.exe at the given path and extract it's // version number. // - outVersionStr: if not null, will capture version as a string (e.g. "1.6") // - outVersionInt: if not null, will capture version as an int (major * 1000 + minor, e.g. 1006). bool getJavaVersion(CPath &javaPath, CString *outVersionStr, int *outVersionInt) { bool result = false; // Run "java -version", which outputs something like to *STDERR*: // // java version "1.6.0_29" // Java(TM) SE Runtime Environment (build 1.6.0_29-b11) // Java HotSpot(TM) Client VM (build 20.4-b02, mixed mode, sharing) // // We want to capture the first line, and more exactly the "1.6" part. CString cmd; cmd.setf("\"%s\" -version", javaPath.cstr()); SECURITY_ATTRIBUTES saAttr; STARTUPINFO startup; PROCESS_INFORMATION pinfo; // Want to inherit pipe handle ZeroMemory(&saAttr, sizeof(saAttr)); saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); saAttr.bInheritHandle = TRUE; saAttr.lpSecurityDescriptor = NULL; // Create pipe for stdout HANDLE stdoutPipeRd, stdoutPipeWt; if (!CreatePipe( &stdoutPipeRd, // hReadPipe, &stdoutPipeWt, // hWritePipe, &saAttr, // lpPipeAttributes, 0)) { // nSize (0=default buffer size) if (gIsConsole || gIsDebug) displayLastError("CreatePipe failed: "); return false; } if (!SetHandleInformation(stdoutPipeRd, HANDLE_FLAG_INHERIT, 0)) { if (gIsConsole || gIsDebug) displayLastError("SetHandleInformation failed: "); return false; } ZeroMemory(&pinfo, sizeof(pinfo)); ZeroMemory(&startup, sizeof(startup)); startup.cb = sizeof(startup); startup.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESTDHANDLES; startup.wShowWindow = SW_HIDE|SW_MINIMIZE; // Capture both stderr and stdout startup.hStdError = stdoutPipeWt; startup.hStdOutput = stdoutPipeWt; startup.hStdInput = GetStdHandle(STD_INPUT_HANDLE); BOOL ok = CreateProcessA( NULL, // program path (LPSTR) cmd.cstr(), // command-line NULL, // process handle is not inheritable NULL, // thread handle is not inheritable TRUE, // yes, inherit some handles 0, // process creation flags NULL, // use parent's environment block NULL, // use parent's starting directory &startup, // startup info, i.e. std handles &pinfo); if ((gIsConsole || gIsDebug) && !ok) displayLastError("CreateProcess failed: "); // Close the write-end of the output pipe (we're only reading from it) CloseHandle(stdoutPipeWt); // Read from the output pipe. We don't need to read everything, // the first line should be 'Java version "1.2.3_45"\r\n' // so reading about 32 chars is all we need. char first32[32 + 1]; int index = 0; first32[0] = 0; if (ok) { #define SIZE 1024 char buffer[SIZE]; DWORD sizeRead = 0; while (ok) { // Keep reading in the same buffer location ok = ReadFile(stdoutPipeRd, // hFile buffer, // lpBuffer SIZE, // DWORD buffer size to read &sizeRead, // DWORD buffer size read NULL); // overlapped if (!ok || sizeRead == 0 || sizeRead > SIZE) break; // Copy up to the first 32 characters if (index < 32) { DWORD n = 32 - index; if (n > sizeRead) n = sizeRead; // copy as lowercase to simplify checks later for (char *b = buffer; n > 0; n--, b++, index++) { char c = *b; if (c >= 'A' && c <= 'Z') c += 'a' - 'A'; first32[index] = c; } first32[index] = 0; } } WaitForSingleObject(pinfo.hProcess, INFINITE); DWORD exitCode; if (GetExitCodeProcess(pinfo.hProcess, &exitCode)) { // this should not return STILL_ACTIVE (259) result = exitCode == 0; } CloseHandle(pinfo.hProcess); CloseHandle(pinfo.hThread); } CloseHandle(stdoutPipeRd); if (result && index > 0) { // Look for a few keywords in the output however we don't // care about specific ordering or case-senstiviness. // We only captures roughtly the first line in lower case. char *j = strstr(first32, "java"); char *v = strstr(first32, "version"); if ((gIsConsole || gIsDebug) && (!j || !v)) { fprintf(stderr, "Error: keywords 'java version' not found in '%s'\n", first32); } if (j != NULL && v != NULL) { result = extractJavaVersion(first32, index, outVersionStr, outVersionInt); } } return result; } #endif /* _WIN32 */