/*
* Copyright (C) 2014 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.
*/
#include "stdafx.h"
#include "JavaFinder.h"
#include "utils.h"
#include <algorithm> // std::sort and std::unique
#define _CRT_SECURE_NO_WARNINGS
// --------------
#define JF_REGISTRY_KEY _T("Software\\Android\\FindJava2")
#define JF_REGISTRY_VALUE_PATH _T("JavaPath")
#define JF_REGISTRY_VALUE_VERS _T("JavaVers")
// --------------
// 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 TCHAR *start,
int length,
CString *outVersionStr,
int *outVersionInt) {
const TCHAR *end = start + length;
for (const TCHAR *c = start; c < end - 2; c++) {
if (isdigit(c[0]) &&
c[1] == '.' &&
isdigit(c[2])) {
const TCHAR *e = c + 2;
while (isdigit(e[1])) {
e++;
}
outVersionStr->SetString(c, e - c + 1);
// major is currently only 1 digit
int major = (*c - '0');
// add minor
int minor = 0;
for (int m = 1; *e != '.'; e--, m *= 10) {
minor += (*e - '0') * m;
}
*outVersionInt = JAVA_VERS_TO_INT(major, minor);
return true;
}
}
return false;
}
// Tries to invoke the java.exe at the given path and extract it's
// version number.
// - outVersionStr: not null, will capture version as a string (e.g. "1.6")
// - outVersionInt: not null, will capture version as an int (see JavaPath.h).
bool getJavaVersion(CPath &javaPath, CString *outVersionStr, int *outVersionInt) {
bool result = false;
// Run "java -version", which outputs something to *STDERR* like this:
//
// 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.Format(_T("\"%s\" -version"), (LPCTSTR) javaPath);
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)
// In FindJava2, we do not report these errors. Leave commented for reference.
// // if (gIsConsole || gIsDebug) displayLastError("CreatePipe failed: ");
return false;
}
if (!SetHandleInformation(stdoutPipeRd, HANDLE_FLAG_INHERIT, 0)) {
// In FindJava2, we do not report these errors. Leave commented for reference.
// // 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 = CreateProcess(
NULL, // program path
(LPTSTR)((LPCTSTR) cmd),// 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);
// In FindJava2, we do not report these errors. Leave commented for reference.
// // 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.
TCHAR 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
// Note: ReadFile uses a char buffer, not a TCHAR one.
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 capture roughtly the first line in lower case.
TCHAR *j = _tcsstr(first32, _T("java"));
TCHAR *v = _tcsstr(first32, _T("version"));
// In FindJava2, we do not report these errors. Leave commented for reference.
// // 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;
}
// --------------
// Checks 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) {
// Append java.exe to path if not already present
CString &p = (CString&)*inOutPath;
int n = p.GetLength();
if (n < 9 || p.Right(9).CompareNoCase(_T("\\java.exe")) != 0) {
inOutPath->Append(_T("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.
CString versionStr;
if (!getJavaVersion(*inOutPath, &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) {
// Append bin to path if not already present
CString &p = (CString&)*inOutPath;
int n = p.GetLength();
if (n < 4 || p.Right(4).CompareNoCase(_T("\\bin")) != 0) {
inOutPath->Append(_T("bin"));
}
return checkPath(inOutPath);
}
// Search java.exe in the environment
static void findJavaInEnvPath(std::set<CJavaPath> *outPaths) {
::SetLastError(0);
const TCHAR* envPath = _tgetenv(_T("JAVA_HOME"));
if (envPath != NULL) {
CPath p(envPath);
int v = checkBinPath(&p);
if (v > 0) {
outPaths->insert(CJavaPath(v, p));
}
}
envPath = _tgetenv(_T("PATH"));
if (envPath != NULL) {
// Otherwise look at the entries in the current path.
// If we find more than one, keep the one with the highest version.
CString pathTokens(envPath);
int curPos = 0;
CString tok;
do {
tok = pathTokens.Tokenize(_T(";"), curPos);
if (!tok.IsEmpty()) {
CPath p(tok);
int v = checkPath(&p);
if (v > 0) {
outPaths->insert(CJavaPath(v, p));
}
}
} while (!tok.IsEmpty());
}
}
// --------------
static bool getRegValue(const TCHAR *keyPath,
const TCHAR *keyName,
REGSAM access,
CString *outValue) {
HKEY key;
LSTATUS status = RegOpenKeyEx(
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
TCHAR* buffer = (TCHAR*)malloc(size);
while (ret == ERROR_MORE_DATA && size < (1 << 16) /*64 KB*/) {
ret = RegQueryValueEx(
key, // hKey
keyName, // lpValueName
NULL, // lpReserved
NULL, // lpType
(LPBYTE)buffer, // lpData
&size); // lpcbData
if (ret == ERROR_MORE_DATA) {
size *= 2;
buffer = (TCHAR*)realloc(buffer, size);
} else {
buffer[size] = 0;
}
}
if (ret != ERROR_MORE_DATA) {
outValue->SetString(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 TCHAR *entry, REGSAM access, std::set<CJavaPath> *outPaths) {
// Let's visit HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment [CurrentVersion]
CPath rootKey(_T("SOFTWARE\\JavaSoft\\"));
rootKey.Append(entry);
CString currentVersion;
CPath subKey(rootKey);
if (getRegValue(subKey, _T("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.Append(currentVersion);
CString value;
if (getRegValue(subKey, _T("JavaHome"), access, &value)) {
CPath javaHome(value);
int v = checkBinPath(&javaHome);
if (v > 0) {
outPaths->insert(CJavaPath(v, javaHome));
}
}
}
// Try again, but this time look at all the versions available
HKEY javaHomeKey;
LSTATUS status = RegOpenKeyEx(
HKEY_LOCAL_MACHINE, // hKey
_T("SOFTWARE\\JavaSoft"), // lpSubKey
0, // ulOptions
KEY_READ | access, // samDesired
&javaHomeKey); // phkResult
if (status == ERROR_SUCCESS) {
TCHAR name[MAX_PATH + 1];
DWORD index = 0;
CPath javaHome;
for (LONG result = ERROR_SUCCESS; result == ERROR_SUCCESS; index++) {
DWORD nameLen = MAX_PATH;
name[nameLen] = 0;
result = RegEnumKeyEx(
javaHomeKey, // hKey
index, // dwIndex
name, // lpName
&nameLen, // lpcName
NULL, // lpReserved
NULL, // lpClass
NULL, // lpcClass,
NULL); // lpftLastWriteTime
if (result == ERROR_SUCCESS && nameLen < MAX_PATH) {
name[nameLen] = 0;
CPath subKey(rootKey);
subKey.Append(name);
CString value;
if (getRegValue(subKey, _T("JavaHome"), access, &value)) {
CPath javaHome(value);
int v = checkBinPath(&javaHome);
if (v > 0) {
outPaths->insert(CJavaPath(v, javaHome));
}
}
}
}
RegCloseKey(javaHomeKey);
}
return 0;
}
static void findJavaInRegistry(std::set<CJavaPath> *outPaths) {
// 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.
exploreJavaRegistry(_T("Java Runtime Environment"), 0, outPaths);
exploreJavaRegistry(_T("Java Development Kit"), 0, outPaths);
// 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.
exploreJavaRegistry(_T("Java Runtime Environment"), KEY_WOW64_32KEY, outPaths);
exploreJavaRegistry(_T("Java Development Kit"), KEY_WOW64_32KEY, outPaths);
} else if (programArch != PROCESSOR_ARCHITECTURE_AMD64) {
// If we did the 64-bit case earlier, don't do it twice.
exploreJavaRegistry(_T("Java Runtime Environment"), KEY_WOW64_64KEY, outPaths);
exploreJavaRegistry(_T("Java Development Kit"), KEY_WOW64_64KEY, outPaths);
}
}
}
// --------------
static void checkProgramFiles(std::set<CJavaPath> *outPaths) {
TCHAR programFilesPath[MAX_PATH + 1];
HRESULT result = SHGetFolderPath(
NULL, // hwndOwner
CSIDL_PROGRAM_FILES, // nFolder
NULL, // hToken
SHGFP_TYPE_CURRENT, // dwFlags
programFilesPath); // pszPath
CPath path(programFilesPath);
path.Append(_T("Java"));
// Do we have a C:\\Program Files\\Java directory?
if (!path.IsDirectory()) {
return;
}
CPath glob(path);
glob.Append(_T("j*"));
WIN32_FIND_DATA findData;
HANDLE findH = FindFirstFile(glob, &findData);
if (findH == INVALID_HANDLE_VALUE) {
return;
}
do {
if ((findData.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) != 0) {
CPath temp(path);
temp.Append(findData.cFileName);
// Check C:\\Program Files[x86]\\Java\\j*\\bin\\java.exe
int v = checkBinPath(&temp);
if (v > 0) {
outPaths->insert(CJavaPath(v, temp));
}
}
} while (FindNextFile(findH, &findData) != 0);
FindClose(findH);
}
static void findJavaInProgramFiles(std::set<CJavaPath> *outPaths) {
// 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.
checkProgramFiles(outPaths);
// 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();
checkProgramFiles(outPaths);
revertWow64FsRedirection(oldWow64Value);
}
}
//------
CJavaFinder::CJavaFinder(int minVersion) : mMinVersion(minVersion) {
}
CJavaFinder::~CJavaFinder() {
}
/*
* Checks whether there's a recorded path in the registry and whether
* this path still points to a valid Java executable.
* Returns false if any of these do not match,
* Returns true if both condition match,
* outPath contains the result path when returning true.
*/
CJavaPath CJavaFinder::getRegistryPath() {
CString existing;
CRegKey rk;
if (rk.Open(HKEY_CURRENT_USER, JF_REGISTRY_KEY, KEY_READ) == ERROR_SUCCESS) {
ULONG sLen = MAX_PATH;
TCHAR s[MAX_PATH + 1];
if (rk.QueryStringValue(JF_REGISTRY_VALUE_PATH, s, &sLen) == ERROR_SUCCESS) {
existing.SetString(s);
}
rk.Close();
}
if (!existing.IsEmpty()) {
CJavaPath javaPath;
if (checkJavaPath(existing, &javaPath)) {
return javaPath;
}
}
return CJavaPath::sEmpty;
}
bool CJavaFinder::setRegistryPath(const CJavaPath &javaPath) {
CRegKey rk;
if (rk.Create(HKEY_CURRENT_USER, JF_REGISTRY_KEY) == ERROR_SUCCESS) {
bool ok = rk.SetStringValue(JF_REGISTRY_VALUE_PATH, javaPath.mPath, REG_SZ) == ERROR_SUCCESS &&
rk.SetStringValue(JF_REGISTRY_VALUE_VERS, javaPath.getVersion(), REG_SZ) == ERROR_SUCCESS;
rk.Close();
return ok;
}
return false;
}
void CJavaFinder::findJavaPaths(std::set<CJavaPath> *paths) {
findJavaInEnvPath(paths);
findJavaInProgramFiles(paths);
findJavaInRegistry(paths);
// Exclude any entries that do not match the minimum version.
// The set is going to be fairly small so it's easier to do it here
// than add the filter logic in all the static methods above.
if (mMinVersion > 0) {
for (auto it = paths->begin(); it != paths->end(); ) {
if (it->mVersion < mMinVersion) {
it = paths->erase(it); // C++11 set.erase returns an iterator to the *next* element
} else {
++it;
}
}
}
}
bool CJavaFinder::checkJavaPath(const CString &path, CJavaPath *outPath) {
CPath p(path);
// try this path (if it ends with java.exe) or path\\java.exe
int v = checkPath(&p);
if (v == 0) {
// reset path and try path\\bin\\java.exe
p = CPath(path);
v = checkBinPath(&p);
}
if (v > 0) {
outPath->set(v, p);
return v >= mMinVersion;
}
return false;
}