1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include "base/i18n/icu_util.h"
6 
7 #if defined(OS_WIN)
8 #include <windows.h>
9 #endif
10 
11 #include <string>
12 
13 #include "base/debug/alias.h"
14 #include "base/files/file_path.h"
15 #include "base/files/memory_mapped_file.h"
16 #include "base/logging.h"
17 #include "base/path_service.h"
18 #include "base/strings/string_util.h"
19 #include "base/strings/sys_string_conversions.h"
20 #include "build/build_config.h"
21 #include "third_party/icu/source/common/unicode/putil.h"
22 #include "third_party/icu/source/common/unicode/udata.h"
23 #if (defined(OS_LINUX) && !defined(OS_CHROMEOS)) || defined(OS_ANDROID)
24 #include "third_party/icu/source/i18n/unicode/timezone.h"
25 #endif
26 
27 #if defined(OS_ANDROID)
28 #include "base/android/apk_assets.h"
29 #include "base/android/timezone_utils.h"
30 #endif
31 
32 #if defined(OS_IOS)
33 #include "base/ios/ios_util.h"
34 #endif
35 
36 #if defined(OS_MACOSX)
37 #include "base/mac/foundation_util.h"
38 #endif
39 
40 #if defined(OS_FUCHSIA)
41 #include "base/base_paths_fuchsia.h"
42 #endif
43 
44 namespace base {
45 namespace i18n {
46 
47 #if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_SHARED
48 #define ICU_UTIL_DATA_SYMBOL "icudt" U_ICU_VERSION_SHORT "_dat"
49 #if defined(OS_WIN)
50 #define ICU_UTIL_DATA_SHARED_MODULE_NAME "icudt.dll"
51 #endif
52 #endif
53 
54 namespace {
55 #if !defined(OS_NACL)
56 #if DCHECK_IS_ON()
57 // Assert that we are not called more than once.  Even though calling this
58 // function isn't harmful (ICU can handle it), being called twice probably
59 // indicates a programming error.
60 bool g_check_called_once = true;
61 bool g_called_once = false;
62 #endif  // DCHECK_IS_ON()
63 
64 #if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
65 
66 // To debug http://crbug.com/445616.
67 int g_debug_icu_last_error;
68 int g_debug_icu_load;
69 int g_debug_icu_pf_error_details;
70 int g_debug_icu_pf_last_error;
71 #if defined(OS_WIN)
72 wchar_t g_debug_icu_pf_filename[_MAX_PATH];
73 #endif  // OS_WIN
74 // Use an unversioned file name to simplify a icu version update down the road.
75 // No need to change the filename in multiple places (gyp files, windows
76 // build pkg configurations, etc). 'l' stands for Little Endian.
77 // This variable is exported through the header file.
78 const char kIcuDataFileName[] = "icudtl.dat";
79 #if defined(OS_ANDROID)
80 const char kAndroidAssetsIcuDataFileName[] = "assets/icudtl.dat";
81 #endif
82 
83 // File handle intentionally never closed. Not using File here because its
84 // Windows implementation guards against two instances owning the same
85 // PlatformFile (which we allow since we know it is never freed).
86 PlatformFile g_icudtl_pf = kInvalidPlatformFile;
87 MemoryMappedFile* g_icudtl_mapped_file = nullptr;
88 MemoryMappedFile::Region g_icudtl_region;
89 
LazyInitIcuDataFile()90 void LazyInitIcuDataFile() {
91   if (g_icudtl_pf != kInvalidPlatformFile) {
92     return;
93   }
94 #if defined(OS_ANDROID)
95   int fd = base::android::OpenApkAsset(kAndroidAssetsIcuDataFileName,
96                                        &g_icudtl_region);
97   g_icudtl_pf = fd;
98   if (fd != -1) {
99     return;
100   }
101 // For unit tests, data file is located on disk, so try there as a fallback.
102 #endif  // defined(OS_ANDROID)
103 #if !defined(OS_MACOSX)
104   FilePath data_path;
105   if (!PathService::Get(DIR_ASSETS, &data_path)) {
106     LOG(ERROR) << "Can't find " << kIcuDataFileName;
107     return;
108   }
109 #if defined(OS_WIN)
110   // TODO(brucedawson): http://crbug.com/445616
111   wchar_t tmp_buffer[_MAX_PATH] = {0};
112   wcscpy_s(tmp_buffer, data_path.value().c_str());
113   debug::Alias(tmp_buffer);
114 #endif
115   data_path = data_path.AppendASCII(kIcuDataFileName);
116 
117 #if defined(OS_WIN)
118   // TODO(brucedawson): http://crbug.com/445616
119   wchar_t tmp_buffer2[_MAX_PATH] = {0};
120   wcscpy_s(tmp_buffer2, data_path.value().c_str());
121   debug::Alias(tmp_buffer2);
122 #endif
123 
124 #else  // !defined(OS_MACOSX)
125   // Assume it is in the framework bundle's Resources directory.
126   ScopedCFTypeRef<CFStringRef> data_file_name(
127       SysUTF8ToCFStringRef(kIcuDataFileName));
128   FilePath data_path = mac::PathForFrameworkBundleResource(data_file_name);
129 #if defined(OS_IOS)
130   FilePath override_data_path = base::ios::FilePathOfEmbeddedICU();
131   if (!override_data_path.empty()) {
132     data_path = override_data_path;
133   }
134 #endif  // !defined(OS_IOS)
135   if (data_path.empty()) {
136     LOG(ERROR) << kIcuDataFileName << " not found in bundle";
137     return;
138   }
139 #endif  // !defined(OS_MACOSX)
140   File file(data_path, File::FLAG_OPEN | File::FLAG_READ);
141   if (file.IsValid()) {
142     // TODO(brucedawson): http://crbug.com/445616.
143     g_debug_icu_pf_last_error = 0;
144     g_debug_icu_pf_error_details = 0;
145 #if defined(OS_WIN)
146     g_debug_icu_pf_filename[0] = 0;
147 #endif  // OS_WIN
148 
149     g_icudtl_pf = file.TakePlatformFile();
150     g_icudtl_region = MemoryMappedFile::Region::kWholeFile;
151   }
152 #if defined(OS_WIN)
153   else {
154     // TODO(brucedawson): http://crbug.com/445616.
155     g_debug_icu_pf_last_error = ::GetLastError();
156     g_debug_icu_pf_error_details = file.error_details();
157     wcscpy_s(g_debug_icu_pf_filename, data_path.value().c_str());
158   }
159 #endif  // OS_WIN
160 }
161 
InitializeICUWithFileDescriptorInternal(PlatformFile data_fd,const MemoryMappedFile::Region & data_region)162 bool InitializeICUWithFileDescriptorInternal(
163     PlatformFile data_fd,
164     const MemoryMappedFile::Region& data_region) {
165   // This can be called multiple times in tests.
166   if (g_icudtl_mapped_file) {
167     g_debug_icu_load = 0;  // To debug http://crbug.com/445616.
168     return true;
169   }
170   if (data_fd == kInvalidPlatformFile) {
171     g_debug_icu_load = 1;  // To debug http://crbug.com/445616.
172     LOG(ERROR) << "Invalid file descriptor to ICU data received.";
173     return false;
174   }
175 
176   std::unique_ptr<MemoryMappedFile> icudtl_mapped_file(new MemoryMappedFile());
177   if (!icudtl_mapped_file->Initialize(File(data_fd), data_region)) {
178     g_debug_icu_load = 2;  // To debug http://crbug.com/445616.
179     LOG(ERROR) << "Couldn't mmap icu data file";
180     return false;
181   }
182   g_icudtl_mapped_file = icudtl_mapped_file.release();
183 
184   UErrorCode err = U_ZERO_ERROR;
185   udata_setCommonData(const_cast<uint8_t*>(g_icudtl_mapped_file->data()), &err);
186   if (err != U_ZERO_ERROR) {
187     g_debug_icu_load = 3;  // To debug http://crbug.com/445616.
188     g_debug_icu_last_error = err;
189   }
190 #if defined(OS_ANDROID)
191   else {
192     // On Android, we can't leave it up to ICU to set the default timezone
193     // because ICU's timezone detection does not work in many timezones (e.g.
194     // Australia/Sydney, Asia/Seoul, Europe/Paris ). Use JNI to detect the host
195     // timezone and set the ICU default timezone accordingly in advance of
196     // actual use. See crbug.com/722821 and
197     // https://ssl.icu-project.org/trac/ticket/13208 .
198     base::string16 timezone_id = base::android::GetDefaultTimeZoneId();
199     icu::TimeZone::adoptDefault(icu::TimeZone::createTimeZone(
200         icu::UnicodeString(FALSE, timezone_id.data(), timezone_id.length())));
201   }
202 #endif
203   // Never try to load ICU data from files.
204   udata_setFileAccess(UDATA_ONLY_PACKAGES, &err);
205   return err == U_ZERO_ERROR;
206 }
207 #endif  // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
208 #endif  // !defined(OS_NACL)
209 
210 }  // namespace
211 
212 #if !defined(OS_NACL)
213 #if ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
214 #if defined(OS_ANDROID)
InitializeICUWithFileDescriptor(PlatformFile data_fd,const MemoryMappedFile::Region & data_region)215 bool InitializeICUWithFileDescriptor(
216     PlatformFile data_fd,
217     const MemoryMappedFile::Region& data_region) {
218 #if DCHECK_IS_ON()
219   DCHECK(!g_check_called_once || !g_called_once);
220   g_called_once = true;
221 #endif
222   return InitializeICUWithFileDescriptorInternal(data_fd, data_region);
223 }
224 
GetIcuDataFileHandle(MemoryMappedFile::Region * out_region)225 PlatformFile GetIcuDataFileHandle(MemoryMappedFile::Region* out_region) {
226   CHECK_NE(g_icudtl_pf, kInvalidPlatformFile);
227   *out_region = g_icudtl_region;
228   return g_icudtl_pf;
229 }
230 #endif
231 
GetRawIcuMemory()232 const uint8_t* GetRawIcuMemory() {
233   CHECK(g_icudtl_mapped_file);
234   return g_icudtl_mapped_file->data();
235 }
236 
InitializeICUFromRawMemory(const uint8_t * raw_memory)237 bool InitializeICUFromRawMemory(const uint8_t* raw_memory) {
238 #if !defined(COMPONENT_BUILD)
239 #if DCHECK_IS_ON()
240   DCHECK(!g_check_called_once || !g_called_once);
241   g_called_once = true;
242 #endif
243 
244   UErrorCode err = U_ZERO_ERROR;
245   udata_setCommonData(const_cast<uint8_t*>(raw_memory), &err);
246   // Never try to load ICU data from files.
247   udata_setFileAccess(UDATA_ONLY_PACKAGES, &err);
248   return err == U_ZERO_ERROR;
249 #else
250   return true;
251 #endif
252 }
253 
254 #endif  // ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE
255 
InitializeICU()256 bool InitializeICU() {
257 #if DCHECK_IS_ON()
258   DCHECK(!g_check_called_once || !g_called_once);
259   g_called_once = true;
260 #endif
261 
262   bool result;
263 #if (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_SHARED)
264   FilePath data_path;
265   PathService::Get(DIR_ASSETS, &data_path);
266   data_path = data_path.AppendASCII(ICU_UTIL_DATA_SHARED_MODULE_NAME);
267 
268   HMODULE module = LoadLibrary(data_path.value().c_str());
269   if (!module) {
270     LOG(ERROR) << "Failed to load " << ICU_UTIL_DATA_SHARED_MODULE_NAME;
271     return false;
272   }
273 
274   FARPROC addr = GetProcAddress(module, ICU_UTIL_DATA_SYMBOL);
275   if (!addr) {
276     LOG(ERROR) << ICU_UTIL_DATA_SYMBOL << ": not found in "
277                << ICU_UTIL_DATA_SHARED_MODULE_NAME;
278     return false;
279   }
280 
281   UErrorCode err = U_ZERO_ERROR;
282   udata_setCommonData(reinterpret_cast<void*>(addr), &err);
283   // Never try to load ICU data from files.
284   udata_setFileAccess(UDATA_ONLY_PACKAGES, &err);
285   result = (err == U_ZERO_ERROR);
286 #elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_STATIC)
287   // The ICU data is statically linked.
288   result = true;
289 #elif (ICU_UTIL_DATA_IMPL == ICU_UTIL_DATA_FILE)
290   // If the ICU data directory is set, ICU won't actually load the data until
291   // it is needed.  This can fail if the process is sandboxed at that time.
292   // Instead, we map the file in and hand off the data so the sandbox won't
293   // cause any problems.
294   LazyInitIcuDataFile();
295   result =
296       InitializeICUWithFileDescriptorInternal(g_icudtl_pf, g_icudtl_region);
297 #if defined(OS_WIN)
298   int debug_icu_load = g_debug_icu_load;
299   debug::Alias(&debug_icu_load);
300   int debug_icu_last_error = g_debug_icu_last_error;
301   debug::Alias(&debug_icu_last_error);
302   int debug_icu_pf_last_error = g_debug_icu_pf_last_error;
303   debug::Alias(&debug_icu_pf_last_error);
304   int debug_icu_pf_error_details = g_debug_icu_pf_error_details;
305   debug::Alias(&debug_icu_pf_error_details);
306   wchar_t debug_icu_pf_filename[_MAX_PATH] = {0};
307   wcscpy_s(debug_icu_pf_filename, g_debug_icu_pf_filename);
308   debug::Alias(&debug_icu_pf_filename);
309   CHECK(result);  // TODO(brucedawson): http://crbug.com/445616
310 #endif
311 #endif
312 
313 // To respond to the timezone change properly, the default timezone
314 // cache in ICU has to be populated on starting up.
315 // TODO(jungshik): Some callers do not care about tz at all. If necessary,
316 // add a boolean argument to this function to init'd the default tz only
317 // when requested.
318 #if defined(OS_LINUX) && !defined(OS_CHROMEOS)
319   if (result)
320     std::unique_ptr<icu::TimeZone> zone(icu::TimeZone::createDefault());
321 #endif
322   return result;
323 }
324 #endif  // !defined(OS_NACL)
325 
AllowMultipleInitializeCallsForTesting()326 void AllowMultipleInitializeCallsForTesting() {
327 #if DCHECK_IS_ON() && !defined(OS_NACL)
328   g_check_called_once = false;
329 #endif
330 }
331 
332 }  // namespace i18n
333 }  // namespace base
334