| /* |
| * Copyright (C) 2019 The Android Open Source Project |
| * |
| * 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 |
| * |
| * http://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 "IcuRegistration.h" |
| |
| #include <sys/mman.h> |
| #include <sys/stat.h> |
| #include <sys/types.h> |
| #include <errno.h> |
| #include <fcntl.h> |
| #include <string.h> |
| #include <unistd.h> |
| |
| #include <unicode/udata.h> |
| #include <unicode/utypes.h> |
| |
| #if !defined(__ANDROID__) || defined(NO_ANDROID_LIBLOG) |
| static int PriorityToLevel(char priority) { |
| // Priority is just the array index of priority in kPriorities. |
| static const char* kPriorities = "VDIWEF"; |
| static const int kLogSuppress = sizeof(kPriorities); |
| const char* matching_priority = strchr(kPriorities, toupper(priority)); |
| return (matching_priority != nullptr) ? matching_priority - kPriorities : kLogSuppress; |
| } |
| |
| static int GetHostLogLevel() { |
| const char* log_tags = getenv("ANDROID_LOG_TAGS"); |
| if (log_tags == nullptr) { |
| return 0; |
| } |
| // Find the wildcard prefix if present in ANDROID_LOG_TAGS. |
| static constexpr const char kLogWildcardPrefix[] = "*:"; |
| static constexpr size_t kLogWildcardPrefixLength = sizeof(kLogWildcardPrefix) - 1; |
| const char* wildcard_start = strstr(log_tags, kLogWildcardPrefix); |
| if (wildcard_start == nullptr) { |
| return 0; |
| } |
| // Priority is based on the character after the wildcard prefix. |
| char priority = *(wildcard_start + kLogWildcardPrefixLength); |
| return PriorityToLevel(priority); |
| } |
| |
| bool AIcuHostShouldLog(char priority) { |
| static int g_LogLevel = GetHostLogLevel(); |
| return PriorityToLevel(priority) >= g_LogLevel; |
| } |
| #endif // !defined(__ANDROID__) || defined(NO_ANDROID_LIBLOG) |
| |
| namespace androidicuinit { |
| namespace impl { |
| |
| #if !defined(__ANDROID__) || defined(NO_ANDROID_LIBLOG) |
| // http://b/171371690 Avoid dependency on liblog and libbase on host |
| // Simplified version of android::base::unique_fd for host. |
| class simple_unique_fd final { |
| public: |
| simple_unique_fd(int fd) { |
| reset(fd); |
| } |
| ~simple_unique_fd() { |
| reset(); |
| } |
| int get() { |
| return fd_; |
| } |
| |
| private: |
| int fd_ = -1; |
| void reset(int new_fd = -1) { |
| if (fd_ != -1) { |
| close(fd_); |
| } |
| fd_ = new_fd; |
| } |
| // Disable copy constructor and assignment operator |
| simple_unique_fd(const simple_unique_fd&) = delete; |
| void operator=(const simple_unique_fd&) = delete; |
| |
| }; |
| |
| // A copy of TEMP_FAILURE_RETRY from android-base/macros.h |
| // bionic and glibc both have TEMP_FAILURE_RETRY, but eg Mac OS' libc doesn't. |
| #ifndef TEMP_FAILURE_RETRY |
| #define TEMP_FAILURE_RETRY(exp) \ |
| ({ \ |
| decltype(exp) _rc; \ |
| do { \ |
| _rc = (exp); \ |
| } while (_rc == -1 && errno == EINTR); \ |
| _rc; \ |
| }) |
| #endif |
| #endif // !defined(__ANDROID__) || defined(NO_ANDROID_LIBLOG) |
| |
| // http://b/171371690 Avoid dependency on liblog and libbase on host |
| #if defined(__ANDROID__) && !defined(NO_ANDROID_LIBLOG) |
| typedef android::base::unique_fd aicu_unique_fd; |
| #else |
| typedef simple_unique_fd aicu_unique_fd; |
| #endif |
| |
| // Map in ICU data at the path, returning null to print error if it failed. |
| std::unique_ptr<IcuDataMap> IcuDataMap::Create(const std::string& path) { |
| std::unique_ptr<IcuDataMap> map(new IcuDataMap(path)); |
| |
| if (!map->TryMap()) { |
| // madvise or ICU could fail but mmap still succeeds. |
| // Destructor will take care of cleaning up a partial init. |
| return nullptr; |
| } |
| |
| return map; |
| } |
| |
| // Unmap the ICU data. |
| IcuDataMap::~IcuDataMap() { TryUnmap(); } |
| |
| bool IcuDataMap::TryMap() { |
| // Open the file and get its length. |
| aicu_unique_fd fd(TEMP_FAILURE_RETRY(open(path_.c_str(), O_RDONLY))); |
| |
| if (fd.get() == -1) { |
| AICU_LOGE("Couldn't open '%s': %s", path_.c_str(), strerror(errno)); |
| return false; |
| } |
| |
| struct stat sb; |
| if (fstat(fd.get(), &sb) == -1) { |
| AICU_LOGE("Couldn't stat '%s': %s", path_.c_str(), strerror(errno)); |
| return false; |
| } |
| |
| data_length_ = sb.st_size; |
| |
| // Map it. |
| data_ = |
| mmap(NULL, data_length_, PROT_READ, MAP_SHARED, fd.get(), 0 /* offset */); |
| if (data_ == MAP_FAILED) { |
| AICU_LOGE("Couldn't mmap '%s': %s", path_.c_str(), strerror(errno)); |
| return false; |
| } |
| |
| // Tell the kernel that accesses are likely to be random rather than |
| // sequential. |
| if (madvise(data_, data_length_, MADV_RANDOM) == -1) { |
| AICU_LOGE("Couldn't madvise(MADV_RANDOM) '%s': %s", path_.c_str(), |
| strerror(errno)); |
| return false; |
| } |
| |
| UErrorCode status = U_ZERO_ERROR; |
| |
| // Tell ICU to use our memory-mapped data. |
| udata_setCommonData(data_, &status); |
| if (status != U_ZERO_ERROR) { |
| AICU_LOGE("Couldn't initialize ICU (udata_setCommonData): %s (%s)", |
| u_errorName(status), path_.c_str()); |
| return false; |
| } |
| |
| return true; |
| } |
| |
| bool IcuDataMap::TryUnmap() { |
| // Don't need to do opposite of udata_setCommonData, |
| // u_cleanup (performed in IcuRegistration::~IcuRegistration()) takes care of |
| // it. |
| |
| // Don't need to opposite of madvise, munmap will take care of it. |
| |
| if (data_ != nullptr && data_ != MAP_FAILED) { |
| if (munmap(data_, data_length_) == -1) { |
| AICU_LOGE("Couldn't munmap '%s': %s", path_.c_str(), strerror(errno)); |
| return false; |
| } |
| } |
| |
| // Don't need to close the file, it was closed automatically during TryMap. |
| return true; |
| } |
| |
| } // namespace impl |
| |
| // A pointer to the instance used by Register and Deregister. Since this code |
| // is currently included in a static library this doesn't prevent duplicate |
| // initialization calls. |
| static std::unique_ptr<IcuRegistration> gIcuRegistration; |
| |
| void IcuRegistration::Register() { |
| CHECK(gIcuRegistration.get() == nullptr); |
| |
| gIcuRegistration.reset(new IcuRegistration()); |
| } |
| |
| void IcuRegistration::Deregister() { |
| gIcuRegistration.reset(); |
| } |
| |
| // Init ICU, configuring it and loading the data files. |
| IcuRegistration::IcuRegistration() { |
| // Note: This logic below should match the logic for ICU4J in |
| // TimeZoneDataFiles.java in external/icu/ to ensure consistent behavior between |
| // ICU4C and ICU4J. |
| |
| // Check the timezone override file exists from a mounted APEX file. |
| // If it does, map it so we use its data in preference to later ones. |
| std::string tzModulePath = getTimeZoneModulePath(); |
| if (pathExists(tzModulePath)) { |
| AICU_LOGD("Time zone APEX ICU file found: %s", tzModulePath.c_str()); |
| icu_datamap_from_tz_module_ = impl::IcuDataMap::Create(tzModulePath); |
| if (icu_datamap_from_tz_module_ == nullptr) { |
| AICU_LOGW( |
| "TZ module override file %s exists but could not be loaded. " |
| "Skipping.", |
| tzModulePath.c_str()); |
| } |
| } else { |
| AICU_LOGV("No time zone module override file found: %s", tzModulePath.c_str()); |
| } |
| |
| // Use the ICU data files that shipped with the i18n module for everything |
| // else. |
| std::string i18nModulePath = getI18nModulePath(); |
| icu_datamap_from_i18n_module_ = impl::IcuDataMap::Create(i18nModulePath); |
| if (icu_datamap_from_i18n_module_ == nullptr) { |
| // IcuDataMap::Create() will log on error so there is no need to log here. |
| abort(); |
| } |
| AICU_LOGD("I18n APEX ICU file found: %s", i18nModulePath.c_str()); |
| } |
| |
| // De-init ICU, unloading the data files. Do the opposite of the above function. |
| IcuRegistration::~IcuRegistration() { |
| // Unmap ICU data files. |
| icu_datamap_from_i18n_module_.reset(); |
| icu_datamap_from_tz_module_.reset(); |
| } |
| |
| bool IcuRegistration::pathExists(const std::string& path) { |
| struct stat sb; |
| return stat(path.c_str(), &sb) == 0; |
| } |
| |
| // Returns a string containing the expected path of the (optional) /apex tz |
| // module data file |
| std::string IcuRegistration::getTimeZoneModulePath() { |
| const char* tzdataModulePathPrefix = getenv("ANDROID_TZDATA_ROOT"); |
| if (tzdataModulePathPrefix == NULL) { |
| AICU_LOGE("ANDROID_TZDATA_ROOT environment variable not set"); |
| abort(); |
| } |
| |
| std::string tzdataModulePath; |
| tzdataModulePath = tzdataModulePathPrefix; |
| tzdataModulePath += "/etc/icu/icu_tzdata.dat"; |
| return tzdataModulePath; |
| } |
| |
| std::string IcuRegistration::getI18nModulePath() { |
| const char* i18nModulePathPrefix = getenv("ANDROID_I18N_ROOT"); |
| if (i18nModulePathPrefix == NULL) { |
| AICU_LOGE("ANDROID_I18N_ROOT environment variable not set"); |
| abort(); |
| } |
| |
| std::string i18nModulePath; |
| i18nModulePath = i18nModulePathPrefix; |
| i18nModulePath += "/etc/icu/" U_ICUDATA_NAME ".dat"; |
| return i18nModulePath; |
| } |
| |
| } // namespace androidicuinit |
| |
| void android_icu_register() { |
| androidicuinit::IcuRegistration::Register(); |
| } |
| |
| void android_icu_deregister() { |
| androidicuinit::IcuRegistration::Deregister(); |
| } |
| |
| bool android_icu_is_registered() { |
| return androidicuinit::gIcuRegistration.get() != nullptr; |
| } |