3 files changed, 370 insertions, 26 deletions
diff --git a/sdkmanager/win_android/find_java.cpp b/sdkmanager/win_android/find_java.cpp
index a3b7af8..eea09ef 100755
--- a/sdkmanager/win_android/find_java.cpp
+++ b/sdkmanager/win_android/find_java.cpp
@@ -17,47 +17,305 @@
 #ifdef _WIN32
 
 #include "find_java.h"
-
-#define _CRT_SECURE_NO_WARNINGS 1
+#include <shlobj.h>
 
 extern bool gDebug;
 
-// Search java.exe in the path
+// Check whether we can find $PATH/java.exe
+static bool checkPath(CPath *inOutPath) {
+    inOutPath->addPath("java.exe");
+
+    bool result = false;
+    PVOID oldWow64Value = disableWow64FsRedirection();
+    if (inOutPath->fileExists()) {
+        // Make sure we can actually run "java -version".
+        CString cmd;
+        cmd.setf("\"%s\" -version", inOutPath->cstr());
+        int code = execWait(cmd.cstr());
+        result = (code == 0);
+    }
+
+    revertWow64FsRedirection(oldWow64Value);
+    return result;
+}
+
+// Check whether we can find $PATH/bin/java.exe
+static bool checkBinPath(CPath *inOutPath) {
+    inOutPath->addPath("bin");
+    return checkPath(inOutPath);
+}
+
+// Search java.exe in the environment
 bool findJavaInEnvPath(CPath *outJavaPath) {
     SetLastError(0);
-    const char* envPath = getenv("PATH");
+
+    const char* envPath = getenv("JAVA_HOME");
+    if (envPath != NULL) {
+        CPath p(envPath);
+        if (checkBinPath(&p)) {
+            if (gDebug) msgBox("Java found via JAVA_HOME: %s", p.cstr());
+            *outJavaPath = p;
+            return true;
+        }
+    }
+
+    envPath = getenv("PATH");
     if (!envPath) return false;
 
     CArray<CString> *paths = CString(envPath).split(';');
     for(int i = 0; i < paths->size(); i++) {
         CPath p((*paths)[i].cstr());
-        p.addPath("java.exe");
-        if (p.fileExists()) {
-            // Make sure we can actually run "java -version".
-            CString cmd;
-            cmd.setf("\"%s\" -version", p.cstr());
-            int code = execWait(cmd.cstr());
-            if (code == 0) {
-                if (gDebug) msgBox("Java found via env path: %s", p.cstr());
-                outJavaPath->set(p.cstr());
-                delete paths;
+        if (checkPath(&p)) {
+            if (gDebug) msgBox("Java found via env PATH: %s", p.cstr());
+            *outJavaPath = p;
+            delete paths;
+            return true;
+        }
+    }
+
+    delete paths;
+    return false;
+}
+
+// --------------
+
+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;
+}
+
+bool exploreJavaRegistry(const char *entry, REGSAM access, CPath *outJavaPath) {
+
+    // Let's visit HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment [CurrentVersion]
+    CPath subKey("SOFTWARE\\JavaSoft\\");
+    subKey.addPath(entry);
+
+    CString currVersion;
+    if (getRegValue(subKey.cstr(), "CurrentVersion", access, &currVersion)) {
+        // CurrentVersion should be something like "1.7".
+        // We want to read HKEY_LOCAL_MACHINE\SOFTWARE\JavaSoft\Java Runtime Environment\1.7 [JavaHome]
+        subKey.addPath(currVersion);
+        CPath javaHome;
+        if (getRegValue(subKey.cstr(), "JavaHome", access, &javaHome)) {
+            if (checkBinPath(&javaHome)) {
+                *outJavaPath = javaHome;
                 return true;
             }
         }
     }
 
-    delete paths;
     return false;
 }
 
 bool findJavaInRegistry(CPath *outJavaPath) {
-    // TODO
+    // 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 test should be equivalent so we just
+    // need the first case.
+
+    // Check the JRE first, then the JDK.
+    if (exploreJavaRegistry("Java Runtime Environment", 0, outJavaPath) ||
+            exploreJavaRegistry("Java Development Kit", 0, outJavaPath)) {
+        return true;
+    }
+
+    // Check the real sysinfo state (not the one hidden by WOW64) for x86
+    SYSTEM_INFO sysInfo;
+    GetNativeSystemInfo(&sysInfo);
+
+    if (sysInfo.wProcessorArchitecture == PROCESSOR_ARCHITECTURE_AMD64) {
+        if (exploreJavaRegistry("Java Runtime Environment", KEY_WOW64_32KEY, outJavaPath) ||
+                exploreJavaRegistry("Java Development Kit", KEY_WOW64_32KEY, outJavaPath)) {
+            return true;
+        }
+
+        if (exploreJavaRegistry("Java Runtime Environment", KEY_WOW64_64KEY, outJavaPath) ||
+                exploreJavaRegistry("Java Development Kit", KEY_WOW64_64KEY, outJavaPath)) {
+            return true;
+        }
+    }
+
     return false;
 }
 
+// --------------
+
+static bool checkProgramFiles(CPath *outJavaPath) {
+
+    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\\{jdk,jre}*\\bin\\java.exe
+            if (checkBinPath(&temp)) {
+                found = true;
+                *outJavaPath = temp;
+            }
+        }
+    } while (!found && FindNextFileA(findH, &findData) != 0);
+    FindClose(findH);
+
+    return found;
+}
+
 bool findJavaInProgramFiles(CPath *outJavaPath) {
-    // TODO
+    // 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.
+    if (checkProgramFiles(outJavaPath)) return true;
+
+    // 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();
+        bool found = checkProgramFiles(outJavaPath);
+        revertWow64FsRedirection(oldWow64Value);
+        return found;
+    }
+
     return false;
 }
 
+// --------------
+
+static bool getJavaVersion(CPath &javaPath, CString *version) {
+    bool result = false;
+
+    // Run "java -version".
+    // TODO: capture output to string.
+    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)
+        displayLastError("CreatePipe failed: ");
+        return false;
+    }
+
+
+    ZeroMemory(&pinfo, sizeof(pinfo));
+
+    ZeroMemory(&startup, sizeof(startup));
+    startup.cb          = sizeof(startup);
+    startup.dwFlags     = STARTF_USESHOWWINDOW;
+    startup.wShowWindow = SW_HIDE|SW_MINIMIZE;
+
+    int ret = CreateProcessA(
+            NULL,                                       /* program path */
+            (LPSTR) cmd,                                /* command-line */
+            NULL,                  /* process handle is not inheritable */
+            NULL,                   /* thread handle is not inheritable */
+            TRUE,                          /* yes, inherit some handles */
+            CREATE_NO_WINDOW,                /* we don't want a console */
+            NULL,                     /* use parent's environment block */
+            NULL,                    /* use parent's starting directory */
+            &startup,                 /* startup info, i.e. std handles */
+            &pinfo);
+
+    if (ret) {
+        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);
+    CloseHandle(stdoutPipeWt);
+
+    if (result) {
+        // TODO
+        // Parse output of "java -version".
+        // It should be something like:
+        //   java version "1.6.0_29"
+        // (including the quotes.)
+    }
+
+    return result;
+}
+
+
 #endif /* _WIN32 */
diff --git a/sdkmanager/win_android/utils.h b/sdkmanager/win_android/utils.h
index 8c5cdb7..4530380 100755
--- a/sdkmanager/win_android/utils.h
+++ b/sdkmanager/win_android/utils.h
@@ -19,6 +19,8 @@
 
 #ifdef _WIN32
 
+#define _CRT_SECURE_NO_WARNINGS 1
+
 #include <direct.h>
 #include <stdio.h>
 #include <stdarg.h>
@@ -68,14 +70,20 @@ protected:
     char *mStr;
 public:
     CString()                              { mStr = NULL; }
-    CString(const CString &str)            { mStr = str.mStr == NULL ? NULL : _strdup(str.mStr); }
+    CString(const CString &str)            { mStr = NULL; set(str.mStr); }
     explicit CString(const char *str)      { mStr = NULL; set(str); }
     CString(const char *start, int length) { mStr = NULL; set(start, length); }
 
+    CString& operator=(const CString &str) {
+        return set(str.cstr());
+    }
+
     CString& set(const char *str) {
-        _free();
-        if (str != NULL) {
-            mStr = _strdup(str);
+        if (str != mStr) {
+            _free();
+            if (str != NULL) {
+                mStr = _strdup(str);
+            }
         }
         return *this;
     }
@@ -211,10 +219,16 @@ private:
 class CPath : public CString {
 public:
     CPath()                              : CString()    { }
+    CPath(const CString &str)            : CString(str) { }
     CPath(const CPath &str)              : CString(str) { }
     explicit CPath(const char *str)      : CString(str) { }
     CPath(const char *start, int length) : CString(start, length) { }
 
+    CPath& operator=(const CPath &str) {
+        set(str.cstr());
+        return *this;
+    }
+
     // Appends a path segment, adding a \ as necessary.
     CPath& addPath(const CString &s) {
         return addPath(s.cstr());
diff --git a/sdkmanager/win_android/win_android.cpp b/sdkmanager/win_android/win_android.cpp
index 32d090c..3a768ec 100644
--- a/sdkmanager/win_android/win_android.cpp
+++ b/sdkmanager/win_android/win_android.cpp
@@ -29,7 +29,8 @@
 
 #include "utils.h"
 #include "find_java.h"
-
+#include <io.h>
+#include <fcntl.h>
 
 // A NULL-terminated list of directory to create in the temp folder.
 static const char * sMkDirList[] = {
@@ -178,6 +179,7 @@ static bool execSdkManager(const char *javaPath,
     // The default is to use java.exe to automatically dump stdout in
     // the parent console.
     CPath javaExecPath(javaPath);
+    bool redirectStdout = true;
 
     // Attach to the parent console, if there's one.
     if (AttachConsole(-1) == 0) {
@@ -198,10 +200,16 @@ static bool execSdkManager(const char *javaPath,
             PVOID oldWow64Value = disableWow64FsRedirection();
             if (!javaExecPath.fileExists()) {
                 javaExecPath.set(javaPath);
+                redirectStdout = false;
             }
             revertWow64FsRedirection(&oldWow64Value);
         }
     }
+    if (redirectStdout && GetStdHandle(STD_OUTPUT_HANDLE) != NULL) {
+        // If we have an output, redirect to it.
+        freopen("CONOUT$", "w", stdout);
+        freopen("CONOUT$", "w", stderr);
+    }
 
     // Check whether the underlying system is x86 or x86_64.
     // We use GetSystemInfo which will see the one masqueraded by Wow64.
@@ -226,7 +234,7 @@ static bool execSdkManager(const char *javaPath,
     // It's important to not use toolsDir otherwise it would lock that diretory.
 
     CString cmdLine;
-    cmdLine.setf("\"%s\" "                                   // javaPath
+    cmdLine.setf("\"%s\" "                                   // javaExecPath basename
                  "-Dcom.android.sdkmanager.toolsdir=\"%s\" " // toolsDir
                  "-Dcom.android.sdkmanager.workdir=\"%s\" "  // workDir==toolsdir
                  "-classpath \"lib\\sdkmanager.jar;lib\\swtmenubar.jar;lib\\%s\\swt.jar\" " // arch
@@ -247,6 +255,69 @@ static bool execSdkManager(const char *javaPath,
     return true;
 }
 
+// Attaches to a parent console or create one and then redirect stdout
+// and stderr to this console. Returns false if it failed to attach
+// or create the console.
+static bool sendStdoutToConsole() {
+    // See http://stackoverflow.com/questions/4028353 for some background.
+
+    HANDLE hConOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    if (hConOut != NULL) {
+        // Std output is set. Might or might not be a console though.
+        // Try to attach to the parent console and use its ConOut.
+        if (AttachConsole(ATTACH_PARENT_PROCESS) != 0) {
+            goto redirect;
+        }
+    }
+
+    // There is no current console output.
+    // Create one and attach ConOut to stdout.
+    if (AllocConsole() == 0) {
+        displayLastError("AllocConsole failed: ");
+        return false;
+    }
+
+redirect:
+    // Redirect both stdout and stderr.
+    HANDLE hOut = GetStdHandle(STD_OUTPUT_HANDLE);
+    int fdOut = _open_osfhandle((intptr_t) hOut, _O_TEXT);
+    if (fdOut != -1) {
+        FILE *fpOut = _fdopen(fdOut, "w");
+        *stdout = *fpOut;
+    } else {
+        // Workaround for Cygwin when not redirecting to a pipe
+        freopen("CONOUT$", "w", stdout);
+    }
+
+    HANDLE hErr = GetStdHandle(STD_ERROR_HANDLE);
+    int fdErr = _open_osfhandle((intptr_t) hErr, _O_TEXT);
+    if (fdErr != -1) {
+        FILE *fpErr = _fdopen(fdErr, "w");
+        *stderr = *fpErr;
+    } else {
+        // Workaround for Cygwin when not redirecting to a pipe
+        // Note: there's is no such 'CONERR$'. See MSDN for GetStdHandle().
+        freopen("CONOUT$", "w", stderr);
+    }
+    return true;
+}
+
+static void testFindJava() {
+    sendStdoutToConsole();
+
+    CPath javaPath("<not found>");
+    bool ok = findJavaInEnvPath(&javaPath);
+    printf("findJavaInEnvPath: [%s] %s\n", ok ? "OK" : "FAIL", javaPath.cstr());
+
+    javaPath.set("<not found>");
+    ok = findJavaInRegistry(&javaPath);
+    printf("findJavaInRegistry [%s] %s\n", ok ? "OK" : "FAIL", javaPath.cstr());
+
+    javaPath.set("<not found>");
+    ok = findJavaInProgramFiles(&javaPath);
+    printf("findJavaInProgramFiles [%s] %s\n", ok ? "OK" : "FAIL", javaPath.cstr());
+}
+
 int APIENTRY WinMain(HINSTANCE hInstance,
                      HINSTANCE hPrevInstance,
                      LPTSTR    lpCmdLine,
@@ -254,7 +325,10 @@ int APIENTRY WinMain(HINSTANCE hInstance,
 
     gDebug = (getenv("ANDROID_SDKMAN_DEBUG") != NULL);
 
-    PVOID oldWow64Value = disableWow64FsRedirection();
+    if (strcmp(lpCmdLine, "/test") == 0) {
+        testFindJava();
+        return 0;
+    }
 
     CPath javaPath;
     if (!findJavaInEnvPath(&javaPath) &&
@@ -265,8 +339,6 @@ int APIENTRY WinMain(HINSTANCE hInstance,
     }
     _ASSERT(!javaPath.isEmpty());
 
-    revertWow64FsRedirection(oldWow64Value);
-
     // For debugging it's convenient to override the tools directory location
     CPath toolsDir(getenv("ANDROID_SDKMAN_TOOLS_DIR"));
     if (toolsDir.isEmpty()) {