~lzh/A133.git

/* 
* 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, &currentVersion)) { 
        // 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; 
}