Reimplement GetWindowsLocalTimeZone without icu.h

yukawa · yukawa · commit d47ce9c873f5 · 2025-09-08T00:41:17.000+09:00
This commit reimplements my previous commits [1][2], which removed the dependency on WinRT on Windows by using system "icu.dll" (#315) when <icu.h> is available in the build environment. Here are major improvements: * The relevant code is extracted into separate source files "src/time_zone_name_win.{cc,h}". This is also a preparation for implementing TimeZoneIf with Windows time APIs (#328), where one more ICU API needs to be dynamically imported. * The dependency on <icu.h> is removed by locally defining required constants and API prototypes. This should make it possible to build CCTZ with the MinGW toolchain, where <icu.h> is not yet available. * LoadLibraryExW(L"icu.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32) is replaced with LoadLibraryW with the full path to "icu.dll" in the System32 directory, because LOAD_LIBRARY_SEARCH_SYSTEM32 can be ignored when "icu.dll" is already loaded from a non-System32 directory. Let's stick to the system "icu.dll" in favor of predictability. Other than the above improvements, the overall logic remains unchanged. [1]: 2ebbe0d [2]: f8e494f
diff --git a/BUILD b/BUILD
@@ -58,7 +58,13 @@ cc_library(
         "src/time_zone_posix.h",
         "src/tzfile.h",
         "src/zone_info_source.cc",
-    ],
+    ] + select({
+        "@platforms//os:windows": [
+            "src/time_zone_name_win.cc",
+            "src/time_zone_name_win.h",
+        ],
+        "//conditions:default": [],
+    }),
     hdrs = [
         "include/cctz/time_zone.h",
         "include/cctz/zone_info_source.h",
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -85,6 +85,8 @@ add_library(cctz
   src/time_zone_posix.h
   src/tzfile.h
   src/zone_info_source.cc
+  $<IF:$<BOOL:WIN32>,src/time_zone_name_win.cc,>
+  $<IF:$<BOOL:WIN32>,src/time_zone_name_win.h,>
   ${CCTZ_HDRS}
   )
 cctz_target_set_cxx_standard(cctz)
diff --git a/src/time_zone_lookup.cc b/src/time_zone_lookup.cc
@@ -30,30 +30,6 @@
 #include <zircon/types.h>
 #endif
 
-#if defined(_WIN32)
-// Include only when <icu.h> is available.
-// https://learn.microsoft.com/en-us/windows/win32/intl/international-components-for-unicode--icu-
-// https://devblogs.microsoft.com/oldnewthing/20210527-00/?p=105255
-#if defined(__has_include)
-#if __has_include(<icu.h>)
-#define USE_WIN32_LOCAL_TIME_ZONE
-#include <windows.h>
-#pragma push_macro("_WIN32_WINNT")
-#pragma push_macro("NTDDI_VERSION")
-// Minimum _WIN32_WINNT and NTDDI_VERSION to use ucal_getTimeZoneIDForWindowsID
-#undef _WIN32_WINNT
-#define _WIN32_WINNT 0x0A00  // == _WIN32_WINNT_WIN10
-#undef NTDDI_VERSION
-#define NTDDI_VERSION 0x0A000004  // == NTDDI_WIN10_RS3
-#include <icu.h>
-#pragma pop_macro("NTDDI_VERSION")
-#pragma pop_macro("_WIN32_WINNT")
-#include <timezoneapi.h>
-#include <atomic>
-#endif  // __has_include(<icu.h>)
-#endif  // __has_include
-#endif  // _WIN32
-
 #include <array>
 #include <cstdint>
 #include <cstdlib>
@@ -63,83 +39,11 @@
 #include "time_zone_fixed.h"
 #include "time_zone_impl.h"
 
-namespace cctz {
-
-namespace {
-#if defined(USE_WIN32_LOCAL_TIME_ZONE)
-// True if we have already failed to load the API.
-static std::atomic_bool g_ucal_getTimeZoneIDForWindowsIDUnavailable;
-static std::atomic<decltype(ucal_getTimeZoneIDForWindowsID)*>
-    g_ucal_getTimeZoneIDForWindowsIDRef;
-
-std::string win32_local_time_zone() {
-  // If we have already failed to load the API, then just give up.
-  if (g_ucal_getTimeZoneIDForWindowsIDUnavailable.load()) {
-    return "";
-  }
-
-  auto ucal_getTimeZoneIDForWindowsIDFunc =
-      g_ucal_getTimeZoneIDForWindowsIDRef.load();
-  if (ucal_getTimeZoneIDForWindowsIDFunc == nullptr) {
-    // If we have already failed to load the API, then just give up.
-    if (g_ucal_getTimeZoneIDForWindowsIDUnavailable.load()) {
-      return "";
-    }
-
-    const HMODULE icudll = ::LoadLibraryExW(L"icu.dll", nullptr,
-                                            LOAD_LIBRARY_SEARCH_SYSTEM32);
-
-    if (icudll == nullptr) {
-      g_ucal_getTimeZoneIDForWindowsIDUnavailable.store(true);
-      return "";
-    }
-
-    ucal_getTimeZoneIDForWindowsIDFunc =
-        reinterpret_cast<decltype(ucal_getTimeZoneIDForWindowsID)*>(
-            ::GetProcAddress(icudll, "ucal_getTimeZoneIDForWindowsID"));
-
-    if (ucal_getTimeZoneIDForWindowsIDFunc == nullptr) {
-      g_ucal_getTimeZoneIDForWindowsIDUnavailable.store(true);
-      return "";
-    }
-    // store-race is not a problem here, because ::GetProcAddress() returns the
-    // same address for the same function in the same DLL.
-    g_ucal_getTimeZoneIDForWindowsIDRef.store(
-        ucal_getTimeZoneIDForWindowsIDFunc);
-
-    // We intentionally do not call ::FreeLibrary() here to avoid frequent DLL
-    // loadings and unloading. As "icu.dll" is a system library, keeping it on
-    // memory is supposed to have no major drawback.
-  }
-
-  DYNAMIC_TIME_ZONE_INFORMATION info = {};
-  if (::GetDynamicTimeZoneInformation(&info) == TIME_ZONE_ID_INVALID) {
-    return "";
-  }
-
-  std::array<UChar, 128> buffer;
-  UErrorCode status = U_ZERO_ERROR;
-  const auto num_chars_in_buffer = ucal_getTimeZoneIDForWindowsIDFunc(
-      reinterpret_cast<const UChar*>(info.TimeZoneKeyName), -1, nullptr,
-      buffer.data(), static_cast<int32_t>(buffer.size()), &status);
-  if (status != U_ZERO_ERROR || num_chars_in_buffer <= 0 ||
-      num_chars_in_buffer > static_cast<int32_t>(buffer.size())) {
-    return "";
-  }
+#if defined(_WIN32)
+#include "time_zone_name_win.h"
+#endif  // _WIN32
 
-  const int num_bytes_in_utf8 = ::WideCharToMultiByte(
-      CP_UTF8, 0, reinterpret_cast<const wchar_t*>(buffer.data()),
-      static_cast<int>(num_chars_in_buffer), nullptr, 0, nullptr, nullptr);
-  std::string local_time_str;
-  local_time_str.resize(static_cast<size_t>(num_bytes_in_utf8));
-  ::WideCharToMultiByte(CP_UTF8, 0, reinterpret_cast<const wchar_t*>(buffer.data()),
-                        static_cast<int>(num_chars_in_buffer),
-                        &local_time_str[0], num_bytes_in_utf8, nullptr,
-                        nullptr);
-  return local_time_str;
-}
-#endif  // USE_WIN32_LOCAL_TIME_ZONE
-}  // namespace
+namespace cctz {
 
 std::string time_zone::name() const {
   return effective_impl().Name();
@@ -259,8 +163,8 @@ time_zone local_time_zone() {
     zone = primary_tz.c_str();
   }
 #endif
-#if defined(USE_WIN32_LOCAL_TIME_ZONE)
-  std::string win32_tz = win32_local_time_zone();
+#if defined(_WIN32)
+  std::string win32_tz = GetWindowsLocalTimeZone();
   if (!win32_tz.empty()) {
     zone = win32_tz.c_str();
   }
diff --git a/src/time_zone_name_win.cc b/src/time_zone_name_win.cc
@@ -0,0 +1,195 @@
+// Copyright 2025 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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 "time_zone_name_win.h"
+
+#if !defined(NOMINMAX)
+#define NOMINMAX
+#endif  // !defined(NOMINMAX)
+#include <windows.h>
+
+#include <array>
+#include <atomic>
+#include <cstdint>
+#include <limits>
+#include <memory>
+#include <string>
+#include <type_traits>
+#include <utility>
+
+namespace cctz {
+namespace {
+
+// UChar is defined as char16_t in ICU by default, but it is also safe to assume
+// wchar_t and char16_t are equivalent on Windows.
+using UChar = wchar_t;
+
+enum UErrorCode : std::int32_t {
+  U_ZERO_ERROR = 0,
+  U_BUFFER_OVERFLOW_ERROR = 15,
+};
+
+bool U_SUCCESS(UErrorCode error) { return error <= U_ZERO_ERROR; }
+
+using ucal_getTimeZoneIDForWindowsID_func = std::int32_t(__cdecl*)(
+    const UChar* winid, std::int32_t len, const char* region, UChar* id,
+    std::int32_t id_capacity, UErrorCode* status);
+
+std::atomic<bool> g_unavailable;
+std::atomic<ucal_getTimeZoneIDForWindowsID_func>
+    g_ucal_getTimeZoneIDForWindowsID;
+
+struct IcuFunctions {
+  const ucal_getTimeZoneIDForWindowsID_func ucal_getTimeZoneIDForWindowsID;
+};
+
+IcuFunctions Unavailable() { return {nullptr}; }
+
+template <typename T>
+static T AsProcAddress(HMODULE module, const char* name) {
+  static_assert(
+      std::is_pointer<T>::value &&
+          std::is_function<typename std::remove_pointer<T>::type>::value,
+      "T must be a function pointer type");
+  const auto proc_address = ::GetProcAddress(module, name);
+  return reinterpret_cast<T>(reinterpret_cast<void*>(proc_address));
+}
+
+std::wstring GetSystem32Dir() {
+  const UINT length = ::GetSystemDirectoryW(nullptr, 0);
+  if (length == 0) {
+    // This must not happen, which doesn't look to be recoverable.
+    return std::wstring();
+  }
+  std::unique_ptr<wchar_t[]> buffer(new wchar_t[length]);
+  const UINT length_written = ::GetSystemDirectoryW(buffer.get(), length);
+  return std::wstring(buffer.get(), length_written);
+}
+
+IcuFunctions GetIcuFunctions() {
+  // This function is intended to be lock free to avoid potential deadlocks
+  // with loader-lock taken inside LoadLibraryW. As LoadLibraryW and
+  // GetProcAddress are idempotent unless the DLL is unloaded, we just need to
+  // make sure global variables are read/written atomically, where
+  // memory_order_relaxed is also acceptable.
+
+  if (g_unavailable.load(std::memory_order_relaxed)) {
+    return Unavailable();
+  }
+
+  {
+    const auto ucal_getTimeZoneIDForWindowsIDRef =
+        g_ucal_getTimeZoneIDForWindowsID.load(std::memory_order_relaxed);
+    if (ucal_getTimeZoneIDForWindowsIDRef != nullptr) {
+      return {ucal_getTimeZoneIDForWindowsIDRef};
+    }
+  }
+
+  const std::wstring system32_dir = GetSystem32Dir();
+  if (system32_dir.empty()) {
+    g_unavailable.store(true, std::memory_order_relaxed);
+    return Unavailable();
+  }
+
+  // Here LoadLibraryExW(L"icu.dll", nullptr, LOAD_LIBRARY_SEARCH_SYSTEM32) does
+  // not work if "icu.dll" is already loaded from somewhere other than the
+  // system32 directory. Specifying the full path with LoadLibraryW is more
+  // reliable.
+  const std::wstring icu_dll_path = system32_dir + L"\\icu.dll";
+  const HMODULE icu_dll = ::LoadLibraryW(icu_dll_path.c_str());
+  if (icu_dll == nullptr) {
+    g_unavailable.store(true, std::memory_order_relaxed);
+    return Unavailable();
+  }
+
+  const auto ucal_getTimeZoneIDForWindowsIDRef =
+      AsProcAddress<ucal_getTimeZoneIDForWindowsID_func>(
+          icu_dll, "ucal_getTimeZoneIDForWindowsID");
+  if (!ucal_getTimeZoneIDForWindowsIDRef) {
+    g_unavailable.store(true, std::memory_order_relaxed);
+    return Unavailable();
+  }
+
+  g_ucal_getTimeZoneIDForWindowsID.store(ucal_getTimeZoneIDForWindowsIDRef,
+                                         std::memory_order_relaxed);
+
+  return {ucal_getTimeZoneIDForWindowsIDRef};
+}
+
+// Convert wchar_t array (UTF-16) to UTF-8 string
+std::string Utf16ToUtf8(const wchar_t* ptr, size_t size) {
+  if (size > std::numeric_limits<int>::max()) {
+    return std::string();
+  }
+  const int chars_len = static_cast<int>(size);
+  int num_bytes = 0;
+  {
+    std::array<char, 32> buffer;
+    num_bytes =
+        ::WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ptr, chars_len,
+                              buffer.data(), buffer.size(), nullptr, nullptr);
+    if (num_bytes <= buffer.size()) {
+      return std::string(buffer.data(), num_bytes);
+    }
+  }
+  auto buffer = std::unique_ptr<char[]>(new char[num_bytes]);
+  const int num_written_bytes =
+      ::WideCharToMultiByte(CP_UTF8, WC_ERR_INVALID_CHARS, ptr, chars_len,
+                            buffer.get(), num_bytes, nullptr, nullptr);
+  if (num_written_bytes != num_bytes) {
+    return std::string();
+  }
+  return std::string(buffer.get(), num_written_bytes);
+}
+
+}  // namespace
+
+std::string GetWindowsLocalTimeZone() {
+  const auto icu = GetIcuFunctions();
+  if (icu.ucal_getTimeZoneIDForWindowsID == nullptr) {
+    return std::string();
+  }
+
+  DYNAMIC_TIME_ZONE_INFORMATION info = {};
+  if (::GetDynamicTimeZoneInformation(&info) == TIME_ZONE_ID_INVALID) {
+    return std::string();
+  }
+
+  std::int32_t length = 0;
+  {
+    // 32-character is just a guess, but hopefully long enough as a fast-path.
+    std::array<UChar, 32> buffer;
+    UErrorCode status = U_ZERO_ERROR;
+    length = icu.ucal_getTimeZoneIDForWindowsID(info.TimeZoneKeyName, -1,
+                                                nullptr, buffer.data(),
+                                                buffer.size(), &status);
+    if (U_SUCCESS(status)) {
+      return Utf16ToUtf8(buffer.data(), length);
+    }
+    if (status != U_BUFFER_OVERFLOW_ERROR) {
+      return std::string();
+    }
+  }
+  const int buffer_size = length + 1;  // +1 for null terminator
+  auto buffer = std::unique_ptr<UChar[]>(new UChar[buffer_size]);
+  UErrorCode status = U_ZERO_ERROR;
+  length = icu.ucal_getTimeZoneIDForWindowsID(
+      info.TimeZoneKeyName, -1, nullptr, buffer.get(), buffer_size, &status);
+  if (U_SUCCESS(status)) {
+    return Utf16ToUtf8(buffer.get(), length);
+  }
+  return std::string();
+}
+
+}  // namespace cctz
diff --git a/src/time_zone_name_win.h b/src/time_zone_name_win.h
@@ -0,0 +1,26 @@
+// Copyright 2025 Google Inc. All Rights Reserved.
+//
+// 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
+//
+//   https://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.
+
+#ifndef CCTZ_TIME_ZONE_NAME_WIN_H_
+#define CCTZ_TIME_ZONE_NAME_WIN_H_
+
+#include <string>
+
+namespace cctz {
+
+std::string GetWindowsLocalTimeZone();
+
+}  // namespace cctz
+
+#endif  // CCTZ_TIME_ZONE_NAME_WIN_H_

Original file line number	Diff line number	Diff line change
`@@ -85,6 +85,8 @@ add_library(cctz`
`85`	`85`	`src/time_zone_posix.h`
`86`	`86`	`src/tzfile.h`
`87`	`87`	`src/zone_info_source.cc`
	`88`	`+ $<IF:$<BOOL:WIN32>,src/time_zone_name_win.cc,>`
	`89`	`+ $<IF:$<BOOL:WIN32>,src/time_zone_name_win.h,>`
`88`	`90`	`${CCTZ_HDRS}`
`89`	`91`	`)`
`90`	`92`	`cctz_target_set_cxx_standard(cctz)`