Support unicode file paths on Windows

Add support for unicode file paths on Windows. By taking advantage of
weak linking which is applied to many low level IO functions in glibc we
can reimplement those functions on Windows to take the UTF-8 coded path
and convert it to UTF-16 so we can call the wide string version of the
same call. This requires that all paths are UTF-8 encoded which is what
we currently do in most places. Some non-UTF-8 usage is fixed by this
change. This change also introduces functions such as android_open and
android_fopen that allows future code to be written without relying on
replacing calls with weak linking.

Note that one frequently used function that does not have weak linking
enabled is "stat". Hence all uses of stat on the Windows platform have
been replaced with android_stat.

Change-Id: I32861f81f44e1ddd723429fbdd3d26b28bac293f

Author: Bjoern Johansson

Makefile.android-emu.mk

@@ -102,6 +102,7 @@ LOCAL_SRC_FILES := \
     android/utils/exec.cpp \
     android/utils/filelock.c \
     android/utils/file_data.c \
+    android/utils/file_io.cpp \
     android/utils/format.cpp \
     android/utils/host_bitness.cpp \
     android/utils/http_utils.cpp \
@@ -115,7 +116,7 @@ LOCAL_SRC_FILES := \
     android/utils/mapfile.c \
     android/utils/misc.c \
     android/utils/panic.c \
-    android/utils/path.c \
+    android/utils/path.cpp \
     android/utils/path_system.cpp \
     android/utils/property_file.c \
     android/utils/reflist.c \
@@ -141,6 +142,7 @@ LOCAL_SRC_FILES += \
     android/base/system/Win32Utils.cpp \
     android/base/system/Win32UnicodeString.cpp \
     android/utils/win32_cmdline_quote.cpp \
+    android/utils/win32_unicode.cpp \
 
 else
 LOCAL_SRC_FILES += \

android/base/testing/TestTempDir.h

@@ -18,6 +18,7 @@
 #include "android/base/Log.h"
 #include "android/base/String.h"
 #include "android/base/StringFormat.h"
+#include "android/utils/file_io.h"
 
 #ifdef _WIN32
 #include <windows.h>
@@ -129,7 +130,7 @@ class TestTempDir {
             }
             String entry_path = StringFormat("%s/%s", path, entry->d_name);
             struct stat stats;
-            lstat(entry_path.c_str(), &stats);
+            android_lstat(entry_path.c_str(), &stats);
             if (S_ISDIR(stats.st_mode)) {
                 DeleteRecursive(entry_path);
             } else {
@@ -162,17 +163,13 @@ class TestTempDir {
         return result;
     }
 
-    int lstat(const char* path, struct stat* st) {
-        return stat(path, st);
-    }
-
     char* mkdtemp(char* path) {
         char* sep = ::strrchr(path, '/');
         if (sep) {
             struct stat st;
             int ret;
             *sep = '\0';  // temporarily zero-terminate the dirname.
-            ret = ::stat(path, &st);
+            ret = android_stat(path, &st);
             *sep = '/';   // restore full path.
             if (ret < 0) {
                 return NULL;
@@ -219,7 +216,7 @@ class TestTempDir {
         }
         // Check that it exists and is a directory.
         struct stat st;
-        int ret = ::stat(result.c_str(), &st);
+        int ret = android_stat(result.c_str(), &st);
         if (ret < 0 || !S_ISDIR(st.st_mode)) {
             LOG(FATAL) << "Can't find temporary path: ["
                     << result.c_str() << "]";

android/camera/camera-capture-linux.c

@@ -23,6 +23,7 @@
 #include "android/camera/camera-capture.h"
 #include "android/camera/camera-format-converters.h"
 #include "android/utils/eintr_wrapper.h"
+#include "android/utils/file_io.h"
 
 #include <fcntl.h>
 #include <stdio.h>
@@ -498,7 +499,7 @@ _camera_device_open(LinuxCameraDevice* cd)
 {
     struct stat st;
 
-    if (stat(cd->device_name, &st)) {
+    if (android_stat(cd->device_name, &st)) {
         return -1;
     }
 

android/emulation/CpuAccelerator.cpp

@@ -32,6 +32,7 @@
 #include "android/base/StringFormat.h"
 #include "android/cpu_accelerator.h"
 #include "android/utils/file_data.h"
+#include "android/utils/file_io.h"
 #include "android/utils/path.h"
 #include "android/utils/x86_cpuid.h"
 #include "target-i386/hax-interface.h"
@@ -238,7 +239,7 @@ int32_t cpuAcceleratorGetHaxVersion(const char* kext_dir[],
 
     for (size_t i = 0; i < kext_dir_count; i++) {
         struct stat s;
-        int err = stat(kext_dir[i], &s);
+        int err = android_stat(kext_dir[i], &s);
         if (err < 0 || !S_ISDIR(s.st_mode)) {
             // dir not found
             continue;

android/skin/qt/winsys-qt.cpp

@@ -15,6 +15,7 @@
 #endif
 
 #include "android/base/system/System.h"
+#include "android/base/system/Win32UnicodeString.h"
 #include "android/qt/qt_path.h"
 #include "android/skin/rect.h"
 #include "android/skin/resource.h"
@@ -43,8 +44,16 @@
 #include <X11/Xlib.h>
 #endif
 
+#ifdef _WIN32
+#include <windows.h>
+#include <shellapi.h>
+#endif
+
 using android::base::System;
 using android::base::String;
+#ifdef _WIN32
+using android::base::Win32UnicodeString;
+#endif
 
 #define  DEBUG  1
 
@@ -84,12 +93,6 @@ std::shared_ptr<void> skin_winsys_get_shared_ptr() {
 extern void skin_winsys_enter_main_loop(bool no_window, int argc, char** argv) {
     D("Starting QT main loop\n");
 
-    // Make Qt look at the libraries within this installation
-    String qtPath = androidQtGetLibraryDir();
-    QStringList pathList(qtPath.c_str());
-    QCoreApplication::setLibraryPaths(pathList);
-    D("Qt lib path: %s\n", qtPath.c_str());
-
     if (!no_window) {
         // Give Qt the fonts from our resource file
         QFontDatabase fontDb;
@@ -331,6 +334,24 @@ extern void skin_winsys_spawn_thread(bool no_window,
     }
 }
 
+void skin_winsys_setup_library_paths() {
+    // Make Qt look at the libraries within this installation
+    // Despite the fact that we added the plugins directory to the environment
+    // we have to add it here as well to support extended unicode characters
+    // in the library path. Without adding the plugin path here that won't work.
+    // What's even more interesting is that adding the plugin path here is not
+    // enough in itself. It also has to be set through the environment variable
+    // or extended unicode characters won't work
+    String qtLibPath = androidQtGetLibraryDir();
+    String qtPluginsPath = androidQtGetPluginsDir();
+    QStringList pathList;
+    pathList.append(QString::fromUtf8(qtLibPath.c_str()));
+    pathList.append(QString::fromUtf8(qtPluginsPath.c_str()));
+    QApplication::setLibraryPaths(pathList);
+    D("Qt lib path: %s\n", qtLibPath.c_str());
+    D("Qt plugin path: %s\n", qtPluginsPath.c_str());
+}
+
 extern void skin_winsys_start(bool no_window, bool raw_keys) {
     GlobalState* g = globalState();
 #ifdef Q_OS_LINUX
@@ -339,6 +360,8 @@ extern void skin_winsys_start(bool no_window, bool raw_keys) {
     // work (confirmed by grepping through Qt code).
     XInitThreads();
 #endif
+    skin_winsys_setup_library_paths();
+
     if (no_window) {
         g->app = new QCoreApplication(g->argc, g->argv);
         EmulatorQtNoWindow::create();
@@ -394,6 +417,33 @@ extern void skin_winsys_run_ui_update(SkinGenericFunction f, void* data) {
 extern "C" int qt_main(int, char**);
 
 int qMain(int argc, char** argv) {
-    return qt_main(argc, argv);
+    // The arguments coming in here are encoded in whatever local code page
+    // Windows is configured with but we need them to be UTF-8 encoded. So we
+    // use GetCommandLineW and CommandLineToArgvW to get a UTF-16 encoded argv
+    // which we then convert to UTF-8.
+    //
+    // According to the Qt documentation Qt itself doesn't really care about
+    // these as it also uses GetCommandLineW on Windows so this shouldn't cause
+    // problems for Qt. But the emulator uses argv[0] to determine the path of
+    // the emulator executable so we need that to be encoded correctly.
+    int numArgs = 0;
+    wchar_t** wideArgv = CommandLineToArgvW(GetCommandLineW(), &numArgs);
+    if (wideArgv == nullptr) {
+        // If this fails we can at least give it a try with the local code page
+        // As long as there are only ANSI characters in the arguments this works
+        return qt_main(argc, argv);
+    }
+
+    // Store converted strings and pointers to those strings, the pointers are
+    // what will become the argv for qt_main
+    std::vector<String> arguments(numArgs);
+    std::vector<char*> argumentPointers(numArgs);
+
+    for (int i = 0; i < numArgs; ++i) {
+        arguments[i] = Win32UnicodeString::convertToUtf8(wideArgv[i]);
+        argumentPointers[i] = reinterpret_cast<char*>(arguments[i].data());
+    }
+
+    return qt_main(numArgs, &argumentPointers[0]);
 }
 #endif  // _WIN32

android/utils/exec.cpp

@@ -11,12 +11,33 @@
 
 #include "android/utils/exec.h"
 
+#include "android/base/system/Win32UnicodeString.h"
+
 #include <unistd.h>
 
+#ifdef _WIN32
+#include <vector>
+#endif
+
 #ifdef _WIN32
 
+using android::base::Win32UnicodeString;
+
 int safe_execv(const char* path, char* const* argv) {
-   const int res = _spawnv(_P_WAIT, path, (const char* const*)argv);
+   std::vector<Win32UnicodeString> arguments;
+   for (size_t i = 0; argv[i] != nullptr; ++i) {
+      arguments.push_back(Win32UnicodeString(argv[i]));
+   }
+   // Do this in two steps since the pointers might change because of push_back
+   // in the loop above.
+   std::vector<const wchar_t*> argumentPointers;
+   for (const auto& arg : arguments) {
+      argumentPointers.push_back(arg.c_str());
+   }
+   argumentPointers.push_back(nullptr);
+
+   Win32UnicodeString program(path);
+   const int res = _wspawnv(_P_WAIT, program.c_str(), &argumentPointers[0]);
    if (res == -1) {
        return -1;
    }