Merge pull request #2705 from schellap/tls

Convert UTF8 using MultiByteToWideChar

src/corehost/cli/deps_entry.cpp

@@ -181,7 +181,10 @@ bool deps_entry_t::to_hash_matched_path(const pal::string_t& base, pal::string_t
     hash.assign(pal::istreambuf_iterator_t(fstream),
         pal::istreambuf_iterator_t());
     pal::string_t pal_hash;
-    pal::to_palstring(hash.c_str(), &pal_hash);
+    if (!pal::utf8_palstring(hash.c_str(), &pal_hash))
+    {
+        return false;
+    }
 
     // Check if contents match deps entry.
     pal::string_t entry_hash = library_hash.substr(pos + 1);

src/corehost/cli/deps_format.cpp

@@ -383,7 +383,8 @@ bool deps_json_t::load(bool portable, const pal::string_t& deps_path, const rid_
     }
     catch (const std::exception& je)
     {
-        pal::string_t jes = pal::to_palstring(je.what());
+        pal::string_t jes;
+        (void) pal::utf8_palstring(je.what(), &jes);
         trace::error(_X("A JSON parsing exception occurred in [%s]: %s"), deps_path.c_str(), jes.c_str());
         return false;
     }

src/corehost/cli/fxr/fx_muxer.cpp

@@ -133,7 +133,8 @@ pal::string_t fx_muxer_t::resolve_cli_version(const pal::string_t& global_json)
     }
     catch (const std::exception& je)
     {
-        pal::string_t jes = pal::to_palstring(je.what());
+        pal::string_t jes;
+        (void) pal::utf8_palstring(je.what(), &jes);
         trace::error(_X("A JSON parsing exception occurred in [%s]: %s"), global_json.c_str(), jes.c_str());
     }
     trace::verbose(_X("CLI version is [%s] in global json file [%s]"), retval.c_str(), global_json.c_str());

src/corehost/cli/hostpolicy.cpp

@@ -68,13 +68,13 @@ int run(const arguments_t& args)
     };
 
     std::vector<char> tpa_paths_cstr, app_base_cstr, native_dirs_cstr, resources_dirs_cstr, fx_deps, deps;
-    pal::to_clrstring(probe_paths.tpa, &tpa_paths_cstr);
-    pal::to_clrstring(args.app_dir, &app_base_cstr);
-    pal::to_clrstring(probe_paths.native, &native_dirs_cstr);
-    pal::to_clrstring(probe_paths.resources, &resources_dirs_cstr);
+    pal::pal_clrstring(probe_paths.tpa, &tpa_paths_cstr);
+    pal::pal_clrstring(args.app_dir, &app_base_cstr);
+    pal::pal_clrstring(probe_paths.native, &native_dirs_cstr);
+    pal::pal_clrstring(probe_paths.resources, &resources_dirs_cstr);
 
-    pal::to_clrstring(resolver.get_fx_deps_file(), &fx_deps);
-    pal::to_clrstring(resolver.get_deps_file() + _X(";") + resolver.get_fx_deps_file(), &deps);
+    pal::pal_clrstring(resolver.get_fx_deps_file(), &fx_deps);
+    pal::pal_clrstring(resolver.get_deps_file() + _X(";") + resolver.get_fx_deps_file(), &deps);
 
     std::vector<const char*> property_values = {
         // TRUSTED_PLATFORM_ASSEMBLIES
@@ -129,7 +129,7 @@ int run(const arguments_t& args)
     }
 
     std::vector<char> own_path;
-    pal::to_clrstring(args.own_path, &own_path);
+    pal::pal_clrstring(args.own_path, &own_path);
 
     // Initialize CoreCLR
     coreclr::host_handle_t host_handle;
@@ -153,7 +153,7 @@ int run(const arguments_t& args)
     std::vector<const char*> argv(args.app_argc);
     for (int i = 0; i < args.app_argc; i++)
     {
-        pal::to_clrstring(args.app_argv[i], &argv_strs[i]);
+        pal::pal_clrstring(args.app_argv[i], &argv_strs[i]);
         argv[i] = argv_strs[i].data();
     }
 
@@ -172,7 +172,7 @@ int run(const arguments_t& args)
     }
 
     std::vector<char> managed_app;
-    pal::to_clrstring(args.managed_application, &managed_app);
+    pal::pal_clrstring(args.managed_application, &managed_app);
 
     // Leave breadcrumbs for servicing.
     breadcrumb_writer_t writer(&breadcrumbs);
@@ -225,10 +225,11 @@ SHARED_API int corehost_main(const int argc, const pal::char_t* argv[])
 {
     if (trace::is_enabled())
     {
-        trace::info(_X("--- Invoked policy [%s/%s/%s] main = {"),
+        trace::info(_X("--- Invoked policy [%s,%s,%s][%s] main = {"),
             _STRINGIFY(HOST_POLICY_PKG_NAME),
             _STRINGIFY(HOST_POLICY_PKG_VER),
-            _STRINGIFY(HOST_POLICY_PKG_REL_DIR));
+            _STRINGIFY(HOST_POLICY_PKG_REL_DIR),
+            get_arch());
 
         for (int i = 0; i < argc; ++i)
         {

src/corehost/cli/libhost.h

@@ -229,7 +229,7 @@ private:
         out->resize(argc);
         for (int i = 0; i < argc; ++i)
         {
-            pal::to_clrstring(pal::string_t(argv[i]), &(*out)[i]);
+            pal::pal_clrstring(pal::string_t(argv[i]), &(*out)[i]);
         }
     }
 };

src/corehost/cli/runtime_config.cpp

@@ -120,7 +120,8 @@ bool runtime_config_t::ensure_dev_config_parsed()
     }
     catch (const std::exception& je)
     {
-        pal::string_t jes = pal::to_palstring(je.what());
+        pal::string_t jes;
+        (void) pal::utf8_palstring(je.what(), &jes);
         trace::error(_X("A JSON parsing exception occurred in [%s]: %s"), m_dev_path.c_str(), jes.c_str());
         return false;
     }
@@ -167,7 +168,8 @@ bool runtime_config_t::ensure_parsed()
     }
     catch (const std::exception& je)
     {
-        pal::string_t jes = pal::to_palstring(je.what());
+        pal::string_t jes;
+        (void) pal::utf8_palstring(je.what(), &jes);
         trace::error(_X("A JSON parsing exception occurred in [%s]: %s"), m_path.c_str(), jes.c_str());
         return false;
     }

src/corehost/common/pal.h

@@ -117,10 +117,9 @@ namespace pal
     inline size_t strlen(const char_t* str) { return ::wcslen(str); }
     inline void err_vprintf(const char_t* format, va_list vl) { ::vfwprintf(stderr, format, vl); ::fputws(_X("\r\n"), stderr); }
 
-    pal::string_t to_palstring(const std::string& str);
-    void to_palstring(const char* str, pal::string_t* out);
-    void to_clrstring(const pal::string_t& str, std::vector<char>* out);
-    void clr_palstring(const char* out, pal::string_t* str);
+    bool utf8_palstring(const std::string& str, pal::string_t* out);
+    bool pal_clrstring(const pal::string_t& str, std::vector<char>* out);
+    bool clr_palstring(const char* cstr, pal::string_t* out);
 #else
     #ifdef COREHOST_MAKE_DLL
         #define SHARED_API extern "C"
@@ -159,10 +158,9 @@ namespace pal
 
     inline size_t strlen(const char_t* str) { return ::strlen(str); }
     inline void err_vprintf(const char_t* format, va_list vl) { ::vfprintf(stderr, format, vl); ::fputc('\n', stderr); }
-    inline pal::string_t to_palstring(const std::string& str) { return str; }
-    inline void to_palstring(const char* str, pal::string_t* out) { out->assign(str); }
-    inline void to_clrstring(const pal::string_t& str, std::vector<char>* out) { out->assign(str.begin(), str.end()); out->push_back('\0'); }
-    inline void clr_palstring(const char* clr, pal::string_t* str) { str->assign(clr); }
+    inline bool utf8_palstring(const std::string& str, pal::string_t* out) { out->assign(str); return true; }
+    inline bool pal_clrstring(const pal::string_t& str, std::vector<char>* out) { out->assign(str.begin(), str.end()); out->push_back('\0'); return true; }
+    inline bool clr_palstring(const char* cstr, pal::string_t* out) { out->assign(cstr); return true; }
 #endif
 
     bool touch_file(const pal::string_t& path);

src/corehost/common/pal.windows.cpp

@@ -10,8 +10,6 @@
 #include <codecvt>
 #include <ShlObj.h>
 
-static thread_local std::wstring_convert<std::codecvt_utf8<wchar_t>, wchar_t> t_converter;
-
 pal::string_t pal::to_lower(const pal::string_t& in)
 {
     pal::string_t ret = in;
@@ -253,39 +251,42 @@ bool pal::get_own_executable_path(string_t* recv)
     return true;
 }
 
-pal::string_t pal::to_palstring(const std::string& str)
+static bool wchar_convert_helper(DWORD code_page, const char* cstr, int len, pal::string_t* out)
 {
-    return t_converter.from_bytes(str);
+    out->clear();
+
+    // No need of explicit null termination, so pass in the actual length.
+    size_t size = ::MultiByteToWideChar(code_page, 0, cstr, len, nullptr, 0);
+    if (size == 0)
+    {
+        return false;
+    }
+    out->resize(size, '\0');
+    return ::MultiByteToWideChar(code_page, 0, cstr, len, &(*out)[0], out->size()) != 0;
 }
 
-void pal::to_palstring(const char* str, pal::string_t* out)
+bool pal::utf8_palstring(const std::string& str, pal::string_t* out)
 {
-    out->assign(t_converter.from_bytes(str));
+    return wchar_convert_helper(CP_UTF8, &str[0], str.size(), out);
 }
 
-void pal::to_clrstring(const pal::string_t& str, std::vector<char>* out)
+bool pal::pal_clrstring(const pal::string_t& str, std::vector<char>* out)
 {
+    out->clear();
+
     // Pass -1 as we want explicit null termination in the char buffer.
     size_t size = ::WideCharToMultiByte(CP_ACP, 0, str.c_str(), -1, nullptr, 0, nullptr, nullptr);
-    out->resize(size, '\0');
     if (size == 0)
     {
-        return;
+        return false;
     }
-    ::WideCharToMultiByte(CP_ACP, 0, str.c_str(), -1, out->data(), out->size(), nullptr, nullptr);
+    out->resize(size, '\0');
+    return ::WideCharToMultiByte(CP_ACP, 0, str.c_str(), -1, out->data(), out->size(), nullptr, nullptr) != 0;
 }
 
-void pal::clr_palstring(const char* out, pal::string_t* str)
+bool pal::clr_palstring(const char* cstr, pal::string_t* out)
 {
-    // No need of explicit null termination, so pass in the actual length.
-    int len = ::strlen(out);
-    size_t size = ::MultiByteToWideChar(CP_ACP, 0, out, len, nullptr, 0);
-    str->resize(size, '\0');
-    if (size == 0)
-    {
-        return;
-    }
-    ::MultiByteToWideChar(CP_ACP, 0, out, len, &(*str)[0], str->size());
+    return wchar_convert_helper(CP_ACP, cstr, ::strlen(cstr), out);
 }
 
 bool pal::realpath(string_t* path)