| /* Copyright (C) 2007-2008 The Android Open Source Project |
| ** |
| ** This software is licensed under the terms of the GNU General Public |
| ** License version 2, as published by the Free Software Foundation, and |
| ** may be copied, distributed, and modified under those terms. |
| ** |
| ** This program is distributed in the hope that it will be useful, |
| ** but WITHOUT ANY WARRANTY; without even the implied warranty of |
| ** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the |
| ** GNU General Public License for more details. |
| */ |
| #include "android/utils/timezone.h" |
| |
| #include "android/android.h" |
| #include "android/base/memory/ScopedPtr.h" |
| #include "android/utils/bufprint.h" |
| #include "android/utils/debug.h" |
| #include "android/utils/eintr_wrapper.h" |
| #include "android/base/files/PathUtils.h" |
| #include "android/base/system/System.h" |
| #include "android/base/StringFormat.h" |
| #include "android/base/StringView.h" |
| #include "android/base/memory/LazyInstance.h" |
| |
| #include <stdbool.h> |
| #include <stdlib.h> |
| #include <stdio.h> |
| #include <string.h> |
| #include <fstream> |
| #include <sstream> |
| #include <memory> |
| #include <string> |
| |
| #define DEBUG 1 |
| |
| #if 1 |
| # define D_ACTIVE VERBOSE_CHECK(timezone) |
| #else |
| # define D_ACTIVE DEBUG |
| #endif |
| |
| #if DEBUG |
| # define D(...) do { if (D_ACTIVE) fprintf(stderr, __VA_ARGS__); } while (0) |
| #else |
| # define D(...) ((void)0) |
| #endif |
| |
| |
| |
| static const char* get_zoneinfo_timezone( void ); /* forward */ |
| |
| static char android_timezone0[256]; |
| static const char* android_timezone; |
| static int android_timezone_init; |
| |
| static int |
| check_timezone_is_zoneinfo(const char* tz) |
| { |
| const char* slash1 = NULL, *slash2 = NULL; |
| |
| if (tz == NULL) |
| return 0; |
| |
| /* the name must be of the form Area/Location or Area/Location/SubLocation */ |
| slash1 = strchr( tz, '/' ); |
| if (slash1 == NULL || slash1[1] == 0) |
| return 0; |
| |
| slash2 = strchr( slash1+1, '/'); |
| if (slash2 != NULL) { |
| if (slash2[1] == 0 || strchr(slash2+1, '/') != NULL) |
| return 0; |
| } |
| |
| return 1; |
| } |
| |
| char* |
| bufprint_zoneinfo_timezone( char* p, char* end ) |
| { |
| const char* tz = get_zoneinfo_timezone(); |
| |
| if (tz == NULL || !check_timezone_is_zoneinfo(tz)) |
| return bufprint(p, end, "Unknown/Unknown"); |
| else |
| return bufprint(p, end, "%s", tz); |
| } |
| |
| /* on OS X, the timezone directory is always /usr/share/zoneinfo |
| * this makes things easy. |
| */ |
| #if defined(__APPLE__) |
| |
| #include <unistd.h> |
| #include <limits.h> |
| #define LOCALTIME_FILE "/etc/localtime" |
| #define ZONEINFO_DIR "/usr/share/zoneinfo/" |
| static const char* |
| get_zoneinfo_timezone( void ) |
| { |
| if (!android_timezone_init) { |
| const char* tz = getenv("TZ"); |
| char buff[PATH_MAX+1]; |
| |
| android_timezone_init = 1; |
| if (tz == NULL) { |
| int len = readlink(LOCALTIME_FILE, buff, sizeof(buff)); |
| if (len < 0) { |
| dprint( "### WARNING: Could not read %s, something is very wrong on your system", |
| LOCALTIME_FILE); |
| return NULL; |
| } |
| |
| buff[len] = 0; |
| D("%s: %s points to %s\n", __FUNCTION__, LOCALTIME_FILE, buff); |
| if ( memcmp(buff, ZONEINFO_DIR, sizeof(ZONEINFO_DIR)-1) ) { |
| dprint( "### WARNING: %s does not point to %s, can't determine zoneinfo timezone name", |
| LOCALTIME_FILE, ZONEINFO_DIR ); |
| return NULL; |
| } |
| tz = buff + sizeof(ZONEINFO_DIR)-1; |
| if ( !check_timezone_is_zoneinfo(tz) ) { |
| dprint( "### WARNING: %s does not point to zoneinfo-compatible timezone name\n", LOCALTIME_FILE ); |
| return NULL; |
| } |
| } |
| snprintf(android_timezone0, sizeof(android_timezone0), "%s", tz ); |
| android_timezone = android_timezone0; |
| } |
| D( "found timezone %s", android_timezone ); |
| return android_timezone; |
| } |
| |
| #endif /* __APPLE__ */ |
| |
| /* on Linux, with glibc2, the zoneinfo directory can be changed with TZDIR environment variable |
| * but should be /usr/share/zoneinfo by default. /etc/localtime is not guaranteed to exist on |
| * all platforms, so if it doesn't, try $TZDIR/localtime, then /usr/share/zoneinfo/locatime |
| * ugly, isn't it ? |
| * |
| * besides, modern Linux distribution don't make /etc/localtime a symlink but a straight copy of |
| * the original timezone file. the only way to know which zoneinfo name to retrieve is to compare |
| * it with all files in $TZDIR (at least those that match Area/Location or Area/Location/SubLocation |
| */ |
| #if defined(__linux__) || defined (__FreeBSD__) |
| |
| #include <unistd.h> |
| #include <limits.h> |
| #include <sys/stat.h> |
| #include <dirent.h> |
| #include <fcntl.h> |
| #include <errno.h> |
| #include <string.h> |
| |
| #define ZONEINFO_DIR "/usr/share/zoneinfo/" |
| #define LOCALTIME_FILE1 "/etc/localtime" |
| |
| typedef struct { |
| const char* localtime; |
| struct stat localtime_st; |
| char* path_end; |
| char* path_root; |
| char path[ PATH_MAX ]; |
| } ScanDataRec; |
| |
| static int |
| compare_timezone_to_localtime( ScanDataRec* scan, |
| const char* path ) |
| { |
| struct stat st; |
| int fd1, fd2, result = 0; |
| |
| D( "%s: comparing %s:", __FUNCTION__, path ); |
| |
| if ( stat( path, &st ) < 0 ) { |
| D( " can't stat: %s\n", strerror(errno) ); |
| return 0; |
| } |
| |
| if ( st.st_size != scan->localtime_st.st_size ) { |
| D( " size mistmatch (%zd != %zd)\n", (size_t)st.st_size, (size_t)scan->localtime_st.st_size ); |
| return 0; |
| } |
| |
| fd1 = open( scan->localtime, O_RDONLY ); |
| if (fd1 < 0) { |
| D(" can't open %s: %s\n", scan->localtime, strerror(errno) ); |
| return 0; |
| } |
| fd2 = open( path, O_RDONLY ); |
| if (fd2 < 0) { |
| D(" can't open %s: %s\n", path, strerror(errno) ); |
| close(fd1); |
| return 0; |
| } |
| do { |
| off_t nn; |
| |
| for (nn = 0; nn < st.st_size; nn++) { |
| char temp[2]; |
| int ret; |
| |
| ret = HANDLE_EINTR(read(fd1, &temp[0], 1)); |
| if (ret < 0) break; |
| |
| ret = HANDLE_EINTR(read(fd2, &temp[1], 1)); |
| if (ret < 0) break; |
| |
| if (temp[0] != temp[1]) |
| break; |
| } |
| |
| result = (nn == st.st_size); |
| |
| } while (0); |
| |
| D( result ? " MATCH\n" : "no match\n" ); |
| |
| close(fd2); |
| close(fd1); |
| |
| return result; |
| } |
| |
| static const char* |
| scan_timezone_dir( ScanDataRec* scan, |
| char* top, |
| int depth ) |
| { |
| DIR* d = opendir( scan->path ); |
| const char* result = NULL; |
| |
| D( "%s: entering '%s\n", __FUNCTION__, scan->path ); |
| if (d != NULL) { |
| struct dirent* ent; |
| while ((ent = readdir(d)) != NULL) { |
| struct stat ent_st; |
| char* p = top; |
| |
| if (ent->d_name[0] == '.') /* avoid hidden and special files */ |
| continue; |
| |
| p = bufprint( p, scan->path_end, "/%s", ent->d_name ); |
| if (p >= scan->path_end) |
| continue; |
| |
| //D( "%s: scanning '%s'\n", __FUNCTION__, scan->path ); |
| |
| // Important: use lstat() instead of stat() because recent |
| // Ubuntu distributions creates directories full of links, e.g. |
| // /usr/share/info/posix/Australia/Sydney -> ../../Australia/Sydney |
| // and we want to ignore them. |
| if ( lstat( scan->path, &ent_st ) < 0 ) |
| continue; |
| |
| if ( S_ISDIR(ent_st.st_mode) && depth < 2 ) |
| { |
| //D( "%s: directory '%s'\n", __FUNCTION__, scan->path ); |
| result = scan_timezone_dir( scan, p, depth + 1 ); |
| if (result != NULL) |
| break; |
| } |
| else if ( S_ISREG(ent_st.st_mode) && (depth >= 1 && depth <= 2) ) |
| { |
| char* name = scan->path_root + 1; |
| |
| if ( check_timezone_is_zoneinfo( name ) ) |
| { |
| if (compare_timezone_to_localtime( scan, scan->path )) |
| { |
| result = strdup( name ); |
| D( "%s: found '%s'\n", __FUNCTION__, result ); |
| break; |
| } |
| } |
| else |
| { |
| //D( "%s: ignoring '%s'\n", __FUNCTION__, scan->path ); |
| } |
| } |
| } |
| closedir(d); |
| } |
| return result; |
| } |
| |
| static const char* |
| get_zoneinfo_timezone( void ) |
| { |
| if (!android_timezone_init) |
| { |
| const char* tz = getenv( "TZ" ); |
| |
| // if we ever allocate into tz, this object will take care of it. |
| android::base::ScopedCPtr<const char> tzDeleter; |
| |
| android_timezone_init = 1; |
| |
| if ( tz != NULL && !check_timezone_is_zoneinfo(tz) ) { |
| D( "%s: ignoring non zoneinfo formatted TZ environment variable: '%s'\n", |
| __FUNCTION__, tz ); |
| tz = NULL; |
| } |
| |
| if (tz == NULL) { |
| int len; |
| char temp[ PATH_MAX ]; |
| std::string tzdir; |
| std::string localtime; |
| |
| /* determine the correct timezone directory */ |
| { |
| const char* env = getenv("TZDIR"); |
| const char* zoneinfo_dir = ZONEINFO_DIR; |
| |
| if (env == NULL) |
| env = zoneinfo_dir; |
| |
| if ( access( env, R_OK ) != 0 ) { |
| if ( env == zoneinfo_dir ) { |
| fprintf( stderr, |
| "### WARNING: could not find %s directory. unable to determine host timezone\n", env ); |
| } else { |
| D( "%s: TZDIR does not point to valid directory, using %s instead\n", |
| __FUNCTION__, zoneinfo_dir ); |
| env = zoneinfo_dir; |
| } |
| return NULL; |
| } |
| tzdir = env; |
| } |
| |
| /* remove trailing slash, if any */ |
| if (!tzdir.empty() && tzdir.back() == '/') { |
| tzdir.pop_back(); |
| } |
| D( "%s: found timezone dir as %s\n", __FUNCTION__, tzdir.c_str() ); |
| |
| /* try to find the localtime file */ |
| const char* localtimePtr = LOCALTIME_FILE1; |
| if ( access( localtimePtr, R_OK ) != 0 ) { |
| char *p = temp, *end = p + sizeof(temp); |
| |
| p = bufprint( p, end, "%s/%s", tzdir.c_str(), "localtime" ); |
| if (p >= end || access( temp, R_OK ) != 0 ) { |
| fprintf( stderr, "### WARNING: could not find %s or %s. unable to determine host timezone\n", |
| LOCALTIME_FILE1, temp ); |
| goto Exit; |
| } |
| localtimePtr = temp; |
| } |
| localtime = localtimePtr; |
| D( "%s: found localtime file as %s\n", __FUNCTION__, localtime.c_str() ); |
| |
| #if 1 |
| /* if the localtime file is a link, make a quick check */ |
| len = readlink( localtime.c_str(), temp, sizeof(temp)-1 ); |
| if (len >= 0 && len > static_cast<int>(tzdir.size()) + 2) { |
| temp[len] = 0; |
| |
| /* verify that the link points to tzdir/<something> where <something> is a valid zoneinfo name */ |
| if ( !memcmp( temp, tzdir.c_str(), tzdir.size() ) && temp[tzdir.size()] == '/' ) { |
| if ( check_timezone_is_zoneinfo( temp + tzdir.size() + 1 ) ) { |
| /* we have it ! */ |
| tz = temp + tzdir.size() + 1; |
| D( "%s: found zoneinfo timezone %s from %s symlink\n", __FUNCTION__, tz, localtime.c_str() ); |
| goto Exit; |
| } |
| D( "%s: %s link points to non-zoneinfo filename %s, comparing contents\n", |
| __FUNCTION__, localtime.c_str(), temp ); |
| } |
| } |
| #endif |
| |
| /* otherwise, parse all files under tzdir and see if we have something that looks like it */ |
| { |
| ScanDataRec scan[1]; |
| |
| if ( stat( localtime.c_str(), &scan->localtime_st ) < 0 ) { |
| fprintf( stderr, "### WARNING: can't access '%s', unable to determine host timezone\n", |
| localtime.c_str() ); |
| goto Exit; |
| } |
| |
| scan->localtime = localtime.c_str(); |
| scan->path_end = scan->path + sizeof(scan->path); |
| scan->path_root = bufprint( scan->path, scan->path_end, "%s", tzdir.c_str() ); |
| |
| tz = scan_timezone_dir( scan, scan->path_root, 0 ); |
| tzDeleter.reset(tz); |
| } |
| |
| Exit: |
| if (tz == NULL) |
| return NULL; |
| } |
| |
| snprintf(android_timezone0, sizeof(android_timezone0), "%s", tz); |
| android_timezone = android_timezone0; |
| |
| D( "found timezone %s\n", android_timezone ); |
| } |
| return android_timezone; |
| } |
| |
| #endif /* __linux__ */ |
| |
| |
| /* on Windows, we need to translate the Windows timezone into a ZoneInfo one */ |
| #ifdef _WIN32 |
| |
| #include "android/base/files/ScopedRegKey.h" |
| #include "android/base/system/Win32Utils.h" |
| #include <windows.h> |
| typedef struct { |
| const char* win_name; |
| const char* zoneinfo_name; |
| } Win32Timezone; |
| |
| /* table generated from http://www.unicode.org/cldr/charts/latest/supplemental/zone_tzid.html */ |
| static const Win32Timezone _win32_timezones[] = { |
| { "AUS Central Standard Time", "Australia/Darwin" }, |
| { "AUS Eastern Standard Time", "Australia/Sydney" }, |
| { "AUS Eastern Standard Time", "Australia/Melbourne" }, |
| { "Afghanistan Standard Time", "Asia/Kabul" }, |
| { "Alaskan Standard Time", "America/Anchorage" }, |
| { "Alaskan Standard Time", "America/Juneau" }, |
| { "Alaskan Standard Time", "America/Metlakatla" }, |
| { "Alaskan Standard Time", "America/Nome" }, |
| { "Alaskan Standard Time", "America/Sitka" }, |
| { "Alaskan Standard Time", "America/Yakutat" }, |
| { "Aleutian Standard Time", "America/Adak" }, |
| { "Altai Standard Time", "Asia/Barnaul" }, |
| { "Arab Standard Time", "Asia/Riyadh" }, |
| { "Arab Standard Time", "Asia/Bahrain" }, |
| { "Arab Standard Time", "Asia/Kuwait" }, |
| { "Arab Standard Time", "Asia/Qatar" }, |
| { "Arab Standard Time", "Asia/Aden" }, |
| { "Arabian Standard Time", "Asia/Dubai" }, |
| { "Arabian Standard Time", "Asia/Muscat" }, |
| { "Arabian Standard Time", "Etc/GMT-4" }, |
| { "Arabic Standard Time", "Asia/Baghdad" }, |
| { "Argentina Standard Time", "America/Buenos_Aires" }, |
| { "Argentina Standard Time", "America/Argentina/La_Rioja" }, |
| { "Argentina Standard Time", "America/Argentina/Rio_Gallegos" }, |
| { "Argentina Standard Time", "America/Argentina/Salta" }, |
| { "Argentina Standard Time", "America/Argentina/San_Juan" }, |
| { "Argentina Standard Time", "America/Argentina/San_Luis" }, |
| { "Argentina Standard Time", "America/Argentina/Tucuman" }, |
| { "Argentina Standard Time", "America/Argentina/Ushuaia" }, |
| { "Argentina Standard Time", "America/Catamarca" }, |
| { "Argentina Standard Time", "America/Cordoba" }, |
| { "Argentina Standard Time", "America/Jujuy" }, |
| { "Argentina Standard Time", "America/Mendoza" }, |
| { "Astrakhan Standard Time", "Europe/Astrakhan" }, |
| { "Astrakhan Standard Time", "Europe/Ulyanovsk" }, |
| { "Atlantic Standard Time", "America/Halifax" }, |
| { "Atlantic Standard Time", "Atlantic/Bermuda" }, |
| { "Atlantic Standard Time", "America/Glace_Bay" }, |
| { "Atlantic Standard Time", "America/Goose_Bay" }, |
| { "Atlantic Standard Time", "America/Moncton" }, |
| { "Atlantic Standard Time", "America/Thule" }, |
| { "Aus Central W. Standard Time", "Australia/Eucla" }, |
| { "Azerbaijan Standard Time", "Asia/Baku" }, |
| { "Azores Standard Time", "Atlantic/Azores" }, |
| { "Azores Standard Time", "America/Scoresbysund" }, |
| { "Bahia Standard Time", "America/Bahia" }, |
| { "Bangladesh Standard Time", "Asia/Dhaka" }, |
| { "Bangladesh Standard Time", "Asia/Thimphu" }, |
| { "Belarus Standard Time", "Europe/Minsk" }, |
| { "Bougainville Standard Time", "Pacific/Bougainville" }, |
| { "Canada Central Standard Time", "America/Regina" }, |
| { "Canada Central Standard Time", "America/Swift_Current" }, |
| { "Cape Verde Standard Time", "Atlantic/Cape_Verde" }, |
| { "Cape Verde Standard Time", "Etc/GMT+1" }, |
| { "Caucasus Standard Time", "Asia/Yerevan" }, |
| { "Cen. Australia Standard Time", "Australia/Adelaide" }, |
| { "Cen. Australia Standard Time", "Australia/Broken_Hill" }, |
| { "Central America Standard Time", "America/Guatemala" }, |
| { "Central America Standard Time", "America/Belize" }, |
| { "Central America Standard Time", "America/Costa_Rica" }, |
| { "Central America Standard Time", "Pacific/Galapagos" }, |
| { "Central America Standard Time", "America/Tegucigalpa" }, |
| { "Central America Standard Time", "America/Managua" }, |
| { "Central America Standard Time", "America/El_Salvador" }, |
| { "Central America Standard Time", "Etc/GMT+6" }, |
| { "Central Asia Standard Time", "Asia/Almaty" }, |
| { "Central Asia Standard Time", "Antarctica/Vostok" }, |
| { "Central Asia Standard Time", "Asia/Urumqi" }, |
| { "Central Asia Standard Time", "Indian/Chagos" }, |
| { "Central Asia Standard Time", "Asia/Bishkek" }, |
| { "Central Asia Standard Time", "Asia/Qyzylorda" }, |
| { "Central Asia Standard Time", "Etc/GMT-6" }, |
| { "Central Brazilian Standard Time", "America/Cuiaba" }, |
| { "Central Brazilian Standard Time", "America/Campo_Grande" }, |
| { "Central Europe Standard Time", "Europe/Budapest" }, |
| { "Central Europe Standard Time", "Europe/Tirane" }, |
| { "Central Europe Standard Time", "Europe/Prague" }, |
| { "Central Europe Standard Time", "Europe/Podgorica" }, |
| { "Central Europe Standard Time", "Europe/Belgrade" }, |
| { "Central Europe Standard Time", "Europe/Ljubljana" }, |
| { "Central Europe Standard Time", "Europe/Bratislava" }, |
| { "Central European Standard Time", "Europe/Warsaw" }, |
| { "Central European Standard Time", "Europe/Sarajevo" }, |
| { "Central European Standard Time", "Europe/Zagreb" }, |
| { "Central European Standard Time", "Europe/Skopje" }, |
| { "Central Pacific Standard Time", "Pacific/Guadalcanal" }, |
| { "Central Pacific Standard Time", "Antarctica/Macquarie" }, |
| { "Central Pacific Standard Time", "Pacific/Ponape" }, |
| { "Central Pacific Standard Time", "Pacific/Kosrae" }, |
| { "Central Pacific Standard Time", "Pacific/Noumea" }, |
| { "Central Pacific Standard Time", "Pacific/Efate" }, |
| { "Central Pacific Standard Time", "Etc/GMT-11" }, |
| { "Central Standard Time", "America/Chicago" }, |
| { "Central Standard Time", "America/Winnipeg" }, |
| { "Central Standard Time", "America/Rainy_River" }, |
| { "Central Standard Time", "America/Rankin_Inlet" }, |
| { "Central Standard Time", "America/Resolute" }, |
| { "Central Standard Time", "America/Matamoros" }, |
| { "Central Standard Time", "America/Indiana/Knox" }, |
| { "Central Standard Time", "America/Indiana/Tell_City" }, |
| { "Central Standard Time", "America/Menominee" }, |
| { "Central Standard Time", "America/North_Dakota/Beulah" }, |
| { "Central Standard Time", "America/North_Dakota/Center" }, |
| { "Central Standard Time", "America/North_Dakota/New_Salem" }, |
| { "Central Standard Time", "CST6CDT" }, |
| { "Central Standard Time (Mexico)", "America/Mexico_City" }, |
| { "Central Standard Time (Mexico)", "America/Bahia_Banderas" }, |
| { "Central Standard Time (Mexico)", "America/Merida" }, |
| { "Central Standard Time (Mexico)", "America/Monterrey" }, |
| { "Chatham Islands Standard Time", "Pacific/Chatham" }, |
| { "China Standard Time", "Asia/Shanghai" }, |
| { "China Standard Time", "Asia/Hong_Kong" }, |
| { "China Standard Time", "Asia/Macau" }, |
| { "Cuba Standard Time", "America/Havana" }, |
| { "Dateline Standard Time", "Etc/GMT+12" }, |
| { "E. Africa Standard Time", "Africa/Nairobi" }, |
| { "E. Africa Standard Time", "Antarctica/Syowa" }, |
| { "E. Africa Standard Time", "Africa/Djibouti" }, |
| { "E. Africa Standard Time", "Africa/Asmera" }, |
| { "E. Africa Standard Time", "Africa/Addis_Ababa" }, |
| { "E. Africa Standard Time", "Indian/Comoro" }, |
| { "E. Africa Standard Time", "Indian/Antananarivo" }, |
| { "E. Africa Standard Time", "Africa/Khartoum" }, |
| { "E. Africa Standard Time", "Africa/Mogadishu" }, |
| { "E. Africa Standard Time", "Africa/Juba" }, |
| { "E. Africa Standard Time", "Africa/Dar_es_Salaam" }, |
| { "E. Africa Standard Time", "Africa/Kampala" }, |
| { "E. Africa Standard Time", "Indian/Mayotte" }, |
| { "E. Africa Standard Time", "Etc/GMT-3" }, |
| { "E. Australia Standard Time", "Australia/Brisbane" }, |
| { "E. Australia Standard Time", "Australia/Lindeman" }, |
| { "E. Europe Standard Time", "Europe/Chisinau" }, |
| { "E. South America Standard Time", "America/Sao_Paulo" }, |
| { "Easter Island Standard Time", "Pacific/Easter" }, |
| { "Eastern Standard Time", "America/New_York" }, |
| { "Eastern Standard Time", "America/Nassau" }, |
| { "Eastern Standard Time", "America/Toronto" }, |
| { "Eastern Standard Time", "America/Iqaluit" }, |
| { "Eastern Standard Time", "America/Montreal" }, |
| { "Eastern Standard Time", "America/Nipigon" }, |
| { "Eastern Standard Time", "America/Pangnirtung" }, |
| { "Eastern Standard Time", "America/Thunder_Bay" }, |
| { "Eastern Standard Time", "America/Detroit" }, |
| { "Eastern Standard Time", "America/Indiana/Petersburg" }, |
| { "Eastern Standard Time", "America/Indiana/Vincennes" }, |
| { "Eastern Standard Time", "America/Indiana/Winamac" }, |
| { "Eastern Standard Time", "America/Kentucky/Monticello" }, |
| { "Eastern Standard Time", "America/Louisville" }, |
| { "Eastern Standard Time", "EST5EDT" }, |
| { "Eastern Standard Time (Mexico)", "America/Cancun" }, |
| { "Egypt Standard Time", "Africa/Cairo" }, |
| { "Ekaterinburg Standard Time", "Asia/Yekaterinburg" }, |
| { "FLE Standard Time", "Europe/Kiev" }, |
| { "FLE Standard Time", "Europe/Mariehamn" }, |
| { "FLE Standard Time", "Europe/Sofia" }, |
| { "FLE Standard Time", "Europe/Tallinn" }, |
| { "FLE Standard Time", "Europe/Helsinki" }, |
| { "FLE Standard Time", "Europe/Vilnius" }, |
| { "FLE Standard Time", "Europe/Riga" }, |
| { "FLE Standard Time", "Europe/Uzhgorod" }, |
| { "FLE Standard Time", "Europe/Zaporozhye" }, |
| { "Fiji Standard Time", "Pacific/Fiji" }, |
| { "GMT Standard Time", "Europe/London" }, |
| { "GMT Standard Time", "Atlantic/Canary" }, |
| { "GMT Standard Time", "Atlantic/Faeroe" }, |
| { "GMT Standard Time", "Europe/Guernsey" }, |
| { "GMT Standard Time", "Europe/Dublin" }, |
| { "GMT Standard Time", "Europe/Isle_of_Man" }, |
| { "GMT Standard Time", "Europe/Jersey" }, |
| { "GMT Standard Time", "Europe/Lisbon" }, |
| { "GMT Standard Time", "Atlantic/Madeira" }, |
| { "GTB Standard Time", "Europe/Bucharest" }, |
| { "GTB Standard Time", "Asia/Nicosia" }, |
| { "GTB Standard Time", "Europe/Athens" }, |
| { "Georgian Standard Time", "Asia/Tbilisi" }, |
| { "Greenland Standard Time", "America/Godthab" }, |
| { "Greenwich Standard Time", "Atlantic/Reykjavik" }, |
| { "Greenwich Standard Time", "Africa/Ouagadougou" }, |
| { "Greenwich Standard Time", "Africa/Abidjan" }, |
| { "Greenwich Standard Time", "Africa/Accra" }, |
| { "Greenwich Standard Time", "Africa/Banjul" }, |
| { "Greenwich Standard Time", "Africa/Conakry" }, |
| { "Greenwich Standard Time", "Africa/Bissau" }, |
| { "Greenwich Standard Time", "Africa/Monrovia" }, |
| { "Greenwich Standard Time", "Africa/Bamako" }, |
| { "Greenwich Standard Time", "Africa/Nouakchott" }, |
| { "Greenwich Standard Time", "Atlantic/St_Helena" }, |
| { "Greenwich Standard Time", "Africa/Freetown" }, |
| { "Greenwich Standard Time", "Africa/Dakar" }, |
| { "Greenwich Standard Time", "Africa/Sao_Tome" }, |
| { "Greenwich Standard Time", "Africa/Lome" }, |
| { "Haiti Standard Time", "America/Port-au-Prince" }, |
| { "Hawaiian Standard Time", "Pacific/Honolulu" }, |
| { "Hawaiian Standard Time", "Pacific/Rarotonga" }, |
| { "Hawaiian Standard Time", "Pacific/Tahiti" }, |
| { "Hawaiian Standard Time", "Pacific/Johnston" }, |
| { "Hawaiian Standard Time", "Etc/GMT+10" }, |
| { "India Standard Time", "Asia/Calcutta" }, |
| { "Iran Standard Time", "Asia/Tehran" }, |
| { "Israel Standard Time", "Asia/Jerusalem" }, |
| { "Jordan Standard Time", "Asia/Amman" }, |
| { "Kaliningrad Standard Time", "Europe/Kaliningrad" }, |
| { "Korea Standard Time", "Asia/Seoul" }, |
| { "Libya Standard Time", "Africa/Tripoli" }, |
| { "Line Islands Standard Time", "Pacific/Kiritimati" }, |
| { "Line Islands Standard Time", "Etc/GMT-14" }, |
| { "Lord Howe Standard Time", "Australia/Lord_Howe" }, |
| { "Magadan Standard Time", "Asia/Magadan" }, |
| { "Marquesas Standard Time", "Pacific/Marquesas" }, |
| { "Mauritius Standard Time", "Indian/Mauritius" }, |
| { "Mauritius Standard Time", "Indian/Reunion" }, |
| { "Mauritius Standard Time", "Indian/Mahe" }, |
| { "Middle East Standard Time", "Asia/Beirut" }, |
| { "Montevideo Standard Time", "America/Montevideo" }, |
| { "Morocco Standard Time", "Africa/Casablanca" }, |
| { "Morocco Standard Time", "Africa/El_Aaiun" }, |
| { "Mountain Standard Time", "America/Denver" }, |
| { "Mountain Standard Time", "America/Edmonton" }, |
| { "Mountain Standard Time", "America/Cambridge_Bay" }, |
| { "Mountain Standard Time", "America/Inuvik" }, |
| { "Mountain Standard Time", "America/Yellowknife" }, |
| { "Mountain Standard Time", "America/Ojinaga" }, |
| { "Mountain Standard Time", "America/Boise" }, |
| { "Mountain Standard Time", "MST7MDT" }, |
| { "Mountain Standard Time (Mexico)", "America/Chihuahua" }, |
| { "Mountain Standard Time (Mexico)", "America/Mazatlan" }, |
| { "Myanmar Standard Time", "Asia/Rangoon" }, |
| { "Myanmar Standard Time", "Indian/Cocos" }, |
| { "N. Central Asia Standard Time", "Asia/Novosibirsk" }, |
| { "N. Central Asia Standard Time", "Asia/Omsk" }, |
| { "Namibia Standard Time", "Africa/Windhoek" }, |
| { "Nepal Standard Time", "Asia/Katmandu" }, |
| { "New Zealand Standard Time", "Pacific/Auckland" }, |
| { "New Zealand Standard Time", "Antarctica/McMurdo" }, |
| { "Newfoundland Standard Time", "America/St_Johns" }, |
| { "Norfolk Standard Time", "Pacific/Norfolk" }, |
| { "North Asia East Standard Time", "Asia/Irkutsk" }, |
| { "North Asia Standard Time", "Asia/Krasnoyarsk" }, |
| { "North Asia Standard Time", "Asia/Novokuznetsk" }, |
| { "North Korea Standard Time", "Asia/Pyongyang" }, |
| { "Pacific SA Standard Time", "America/Santiago" }, |
| { "Pacific SA Standard Time", "Antarctica/Palmer" }, |
| { "Pacific Standard Time", "America/Los_Angeles" }, |
| { "Pacific Standard Time", "America/Vancouver" }, |
| { "Pacific Standard Time", "America/Dawson" }, |
| { "Pacific Standard Time", "America/Whitehorse" }, |
| { "Pacific Standard Time", "PST8PDT" }, |
| { "Pacific Standard Time (Mexico)", "America/Tijuana" }, |
| { "Pacific Standard Time (Mexico)", "America/Santa_Isabel" }, |
| { "Pakistan Standard Time", "Asia/Karachi" }, |
| { "Paraguay Standard Time", "America/Asuncion" }, |
| { "Romance Standard Time", "Europe/Paris" }, |
| { "Romance Standard Time", "Europe/Brussels" }, |
| { "Romance Standard Time", "Europe/Copenhagen" }, |
| { "Romance Standard Time", "Europe/Madrid" }, |
| { "Romance Standard Time", "Africa/Ceuta" }, |
| { "Russia Time Zone 10", "Asia/Srednekolymsk" }, |
| { "Russia Time Zone 11", "Asia/Kamchatka" }, |
| { "Russia Time Zone 11", "Asia/Anadyr" }, |
| { "Russia Time Zone 3", "Europe/Samara" }, |
| { "Russian Standard Time", "Europe/Moscow" }, |
| { "Russian Standard Time", "Europe/Kirov" }, |
| { "Russian Standard Time", "Europe/Simferopol" }, |
| { "Russian Standard Time", "Europe/Volgograd" }, |
| { "SA Eastern Standard Time", "America/Cayenne" }, |
| { "SA Eastern Standard Time", "Antarctica/Rothera" }, |
| { "SA Eastern Standard Time", "America/Fortaleza" }, |
| { "SA Eastern Standard Time", "America/Belem" }, |
| { "SA Eastern Standard Time", "America/Maceio" }, |
| { "SA Eastern Standard Time", "America/Recife" }, |
| { "SA Eastern Standard Time", "America/Santarem" }, |
| { "SA Eastern Standard Time", "Atlantic/Stanley" }, |
| { "SA Eastern Standard Time", "America/Paramaribo" }, |
| { "SA Eastern Standard Time", "Etc/GMT+3" }, |
| { "SA Pacific Standard Time", "America/Bogota" }, |
| { "SA Pacific Standard Time", "America/Rio_Branco" }, |
| { "SA Pacific Standard Time", "America/Eirunepe" }, |
| { "SA Pacific Standard Time", "America/Coral_Harbour" }, |
| { "SA Pacific Standard Time", "America/Guayaquil" }, |
| { "SA Pacific Standard Time", "America/Jamaica" }, |
| { "SA Pacific Standard Time", "America/Cayman" }, |
| { "SA Pacific Standard Time", "America/Panama" }, |
| { "SA Pacific Standard Time", "America/Lima" }, |
| { "SA Pacific Standard Time", "Etc/GMT+5" }, |
| { "SA Western Standard Time", "America/La_Paz" }, |
| { "SA Western Standard Time", "America/Antigua" }, |
| { "SA Western Standard Time", "America/Anguilla" }, |
| { "SA Western Standard Time", "America/Aruba" }, |
| { "SA Western Standard Time", "America/Barbados" }, |
| { "SA Western Standard Time", "America/St_Barthelemy" }, |
| { "SA Western Standard Time", "America/Kralendijk" }, |
| { "SA Western Standard Time", "America/Manaus" }, |
| { "SA Western Standard Time", "America/Boa_Vista" }, |
| { "SA Western Standard Time", "America/Porto_Velho" }, |
| { "SA Western Standard Time", "America/Blanc-Sablon" }, |
| { "SA Western Standard Time", "America/Curacao" }, |
| { "SA Western Standard Time", "America/Dominica" }, |
| { "SA Western Standard Time", "America/Santo_Domingo" }, |
| { "SA Western Standard Time", "America/Grenada" }, |
| { "SA Western Standard Time", "America/Guadeloupe" }, |
| { "SA Western Standard Time", "America/Guyana" }, |
| { "SA Western Standard Time", "America/St_Kitts" }, |
| { "SA Western Standard Time", "America/St_Lucia" }, |
| { "SA Western Standard Time", "America/Marigot" }, |
| { "SA Western Standard Time", "America/Martinique" }, |
| { "SA Western Standard Time", "America/Montserrat" }, |
| { "SA Western Standard Time", "America/Puerto_Rico" }, |
| { "SA Western Standard Time", "America/Lower_Princes" }, |
| { "SA Western Standard Time", "America/Port_of_Spain" }, |
| { "SA Western Standard Time", "America/St_Vincent" }, |
| { "SA Western Standard Time", "America/Tortola" }, |
| { "SA Western Standard Time", "America/St_Thomas" }, |
| { "SA Western Standard Time", "Etc/GMT+4" }, |
| { "SE Asia Standard Time", "Asia/Bangkok" }, |
| { "SE Asia Standard Time", "Antarctica/Davis" }, |
| { "SE Asia Standard Time", "Indian/Christmas" }, |
| { "SE Asia Standard Time", "Asia/Jakarta" }, |
| { "SE Asia Standard Time", "Asia/Pontianak" }, |
| { "SE Asia Standard Time", "Asia/Phnom_Penh" }, |
| { "SE Asia Standard Time", "Asia/Vientiane" }, |
| { "SE Asia Standard Time", "Asia/Saigon" }, |
| { "SE Asia Standard Time", "Etc/GMT-7" }, |
| { "Saint Pierre Standard Time", "America/Miquelon" }, |
| { "Sakhalin Standard Time", "Asia/Sakhalin" }, |
| { "Samoa Standard Time", "Pacific/Apia" }, |
| { "Singapore Standard Time", "Asia/Singapore" }, |
| { "Singapore Standard Time", "Asia/Brunei" }, |
| { "Singapore Standard Time", "Asia/Makassar" }, |
| { "Singapore Standard Time", "Asia/Kuala_Lumpur" }, |
| { "Singapore Standard Time", "Asia/Kuching" }, |
| { "Singapore Standard Time", "Asia/Manila" }, |
| { "Singapore Standard Time", "Etc/GMT-8" }, |
| { "South Africa Standard Time", "Africa/Johannesburg" }, |
| { "South Africa Standard Time", "Africa/Bujumbura" }, |
| { "South Africa Standard Time", "Africa/Gaborone" }, |
| { "South Africa Standard Time", "Africa/Lubumbashi" }, |
| { "South Africa Standard Time", "Africa/Maseru" }, |
| { "South Africa Standard Time", "Africa/Blantyre" }, |
| { "South Africa Standard Time", "Africa/Maputo" }, |
| { "South Africa Standard Time", "Africa/Kigali" }, |
| { "South Africa Standard Time", "Africa/Mbabane" }, |
| { "South Africa Standard Time", "Africa/Lusaka" }, |
| { "South Africa Standard Time", "Africa/Harare" }, |
| { "South Africa Standard Time", "Etc/GMT-2" }, |
| { "Sri Lanka Standard Time", "Asia/Colombo" }, |
| { "Syria Standard Time", "Asia/Damascus" }, |
| { "Taipei Standard Time", "Asia/Taipei" }, |
| { "Tasmania Standard Time", "Australia/Hobart" }, |
| { "Tasmania Standard Time", "Australia/Currie" }, |
| { "Tocantins Standard Time", "America/Araguaina" }, |
| { "Tokyo Standard Time", "Asia/Tokyo" }, |
| { "Tokyo Standard Time", "Asia/Jayapura" }, |
| { "Tokyo Standard Time", "Pacific/Palau" }, |
| { "Tokyo Standard Time", "Asia/Dili" }, |
| { "Tokyo Standard Time", "Etc/GMT-9" }, |
| { "Tomsk Standard Time", "Asia/Tomsk" }, |
| { "Tonga Standard Time", "Pacific/Tongatapu" }, |
| { "Tonga Standard Time", "Pacific/Enderbury" }, |
| { "Tonga Standard Time", "Pacific/Fakaofo" }, |
| { "Tonga Standard Time", "Etc/GMT-13" }, |
| { "Transbaikal Standard Time", "Asia/Chita" }, |
| { "Turkey Standard Time", "Europe/Istanbul" }, |
| { "Turks And Caicos Standard Time", "America/Grand_Turk" }, |
| { "US Eastern Standard Time", "America/Indianapolis" }, |
| { "US Eastern Standard Time", "America/Indiana/Marengo" }, |
| { "US Eastern Standard Time", "America/Indiana/Vevay" }, |
| { "US Mountain Standard Time", "America/Phoenix" }, |
| { "US Mountain Standard Time", "America/Dawson_Creek" }, |
| { "US Mountain Standard Time", "America/Creston" }, |
| { "US Mountain Standard Time", "America/Fort_Nelson" }, |
| { "US Mountain Standard Time", "America/Hermosillo" }, |
| { "US Mountain Standard Time", "Etc/GMT+7" }, |
| { "UTC", "Etc/GMT" }, |
| { "UTC", "America/Danmarkshavn" }, |
| { "UTC+12", "Etc/GMT-12" }, |
| { "UTC+12", "Pacific/Tarawa" }, |
| { "UTC+12", "Pacific/Majuro" }, |
| { "UTC+12", "Pacific/Kwajalein" }, |
| { "UTC+12", "Pacific/Nauru" }, |
| { "UTC+12", "Pacific/Funafuti" }, |
| { "UTC+12", "Pacific/Wake" }, |
| { "UTC+12", "Pacific/Wallis" }, |
| { "UTC-02", "Etc/GMT+2" }, |
| { "UTC-02", "America/Noronha" }, |
| { "UTC-02", "Atlantic/South_Georgia" }, |
| { "UTC-08", "Etc/GMT+8" }, |
| { "UTC-08", "Pacific/Pitcairn" }, |
| { "UTC-09", "Etc/GMT+9" }, |
| { "UTC-09", "Pacific/Gambier" }, |
| { "UTC-11", "Etc/GMT+11" }, |
| { "UTC-11", "Pacific/Pago_Pago" }, |
| { "UTC-11", "Pacific/Niue" }, |
| { "UTC-11", "Pacific/Midway" }, |
| { "Ulaanbaatar Standard Time", "Asia/Ulaanbaatar" }, |
| { "Ulaanbaatar Standard Time", "Asia/Choibalsan" }, |
| { "Venezuela Standard Time", "America/Caracas" }, |
| { "Vladivostok Standard Time", "Asia/Vladivostok" }, |
| { "Vladivostok Standard Time", "Asia/Ust-Nera" }, |
| { "W. Australia Standard Time", "Australia/Perth" }, |
| { "W. Australia Standard Time", "Antarctica/Casey" }, |
| { "W. Central Africa Standard Time", "Africa/Lagos" }, |
| { "W. Central Africa Standard Time", "Africa/Luanda" }, |
| { "W. Central Africa Standard Time", "Africa/Porto-Novo" }, |
| { "W. Central Africa Standard Time", "Africa/Kinshasa" }, |
| { "W. Central Africa Standard Time", "Africa/Bangui" }, |
| { "W. Central Africa Standard Time", "Africa/Brazzaville" }, |
| { "W. Central Africa Standard Time", "Africa/Douala" }, |
| { "W. Central Africa Standard Time", "Africa/Algiers" }, |
| { "W. Central Africa Standard Time", "Africa/Libreville" }, |
| { "W. Central Africa Standard Time", "Africa/Malabo" }, |
| { "W. Central Africa Standard Time", "Africa/Niamey" }, |
| { "W. Central Africa Standard Time", "Africa/Ndjamena" }, |
| { "W. Central Africa Standard Time", "Africa/Tunis" }, |
| { "W. Central Africa Standard Time", "Etc/GMT-1" }, |
| { "W. Europe Standard Time", "Europe/Berlin" }, |
| { "W. Europe Standard Time", "Europe/Andorra" }, |
| { "W. Europe Standard Time", "Europe/Vienna" }, |
| { "W. Europe Standard Time", "Europe/Zurich" }, |
| { "W. Europe Standard Time", "Europe/Busingen" }, |
| { "W. Europe Standard Time", "Europe/Gibraltar" }, |
| { "W. Europe Standard Time", "Europe/Rome" }, |
| { "W. Europe Standard Time", "Europe/Vaduz" }, |
| { "W. Europe Standard Time", "Europe/Luxembourg" }, |
| { "W. Europe Standard Time", "Europe/Monaco" }, |
| { "W. Europe Standard Time", "Europe/Malta" }, |
| { "W. Europe Standard Time", "Europe/Amsterdam" }, |
| { "W. Europe Standard Time", "Europe/Oslo" }, |
| { "W. Europe Standard Time", "Europe/Stockholm" }, |
| { "W. Europe Standard Time", "Arctic/Longyearbyen" }, |
| { "W. Europe Standard Time", "Europe/San_Marino" }, |
| { "W. Europe Standard Time", "Europe/Vatican" }, |
| { "W. Mongolia Standard Time", "Asia/Hovd" }, |
| { "West Asia Standard Time", "Asia/Tashkent" }, |
| { "West Asia Standard Time", "Antarctica/Mawson" }, |
| { "West Asia Standard Time", "Asia/Oral" }, |
| { "West Asia Standard Time", "Asia/Aqtau" }, |
| { "West Asia Standard Time", "Asia/Aqtobe" }, |
| { "West Asia Standard Time", "Indian/Maldives" }, |
| { "West Asia Standard Time", "Indian/Kerguelen" }, |
| { "West Asia Standard Time", "Asia/Dushanbe" }, |
| { "West Asia Standard Time", "Asia/Ashgabat" }, |
| { "West Asia Standard Time", "Asia/Samarkand" }, |
| { "West Asia Standard Time", "Etc/GMT-5" }, |
| { "West Bank Standard Time", "Asia/Hebron" }, |
| { "West Bank Standard Time", "Asia/Gaza" }, |
| { "West Pacific Standard Time", "Pacific/Port_Moresby" }, |
| { "West Pacific Standard Time", "Antarctica/DumontDUrville" }, |
| { "West Pacific Standard Time", "Pacific/Truk" }, |
| { "West Pacific Standard Time", "Pacific/Guam" }, |
| { "West Pacific Standard Time", "Pacific/Saipan" }, |
| { "West Pacific Standard Time", "Etc/GMT-10" }, |
| { "Yakutsk Standard Time", "Asia/Yakutsk" }, |
| { "Yakutsk Standard Time", "Asia/Khandyga" }, |
| { NULL, NULL } |
| }; |
| |
| static const char* |
| get_zoneinfo_timezone( void ) |
| { |
| if (!android_timezone_init) |
| { |
| char tzname[128]; |
| time_t t = time(NULL); |
| struct tm* tm = localtime(&t); |
| const Win32Timezone* win32tz = _win32_timezones; |
| |
| android_timezone_init = 1; |
| |
| if (!tm) { |
| D("%s: could not determine current date/time\n", __FUNCTION__); |
| return NULL; |
| } |
| |
| memset(tzname, 0, sizeof(tzname)); |
| strftime(tzname, sizeof(tzname) - 1, "%Z", tm); |
| |
| for (win32tz = _win32_timezones; win32tz->win_name != NULL; win32tz++) |
| if ( !strcmp(win32tz->win_name, tzname) ) { |
| android_timezone = win32tz->zoneinfo_name; |
| goto Exit; |
| } |
| |
| #if 0 /* TODO */ |
| /* we didn't find it, this may come from localized versions of Windows. we're going to explore the registry, |
| * as the code in Postgresql does... |
| */ |
| #endif |
| D( "%s: could not determine current timezone\n", __FUNCTION__ ); |
| return NULL; |
| } |
| Exit: |
| D( "emulator: found timezone %s\n", android_timezone ); |
| return android_timezone; |
| } |
| |
| #endif /* _WIN32 */ |
| |
| namespace { |
| |
| static constexpr android::base::StringView kMonthName[] = { |
| "Jan", "Feb", "Mar", "Apr", "May", "Jun", |
| "Jul", "Aug", "Sep", "Oct", "Nov", "Dec" |
| }; |
| class TimeZone { |
| public: |
| TimeZone(); |
| |
| /* Return local time based on android timezone set by function androidTimeZoneSet(). |
| * Fall back to host OS localtime() if android timezone is not set. |
| * */ |
| struct tm* androidLocaltime(const time_t& timeNow); |
| |
| /* Return the timezone offset including day light saving in seconds with respect to |
| * UTC in guest android OS. Fall back to use host OS timezone offset if android time |
| * zone is not set or invalid. |
| * */ |
| long androidTimeZoneOffset(const time_t& timeNow); |
| |
| /* Try to set the default android OS timezone. This operation will affect the |
| * emulated networked time in virtual modem. |
| * When |tzname| is not found or invalid, fall back to use host OS local timezone. |
| * */ |
| int androidTimeZoneSet(const char* tzname); |
| private: |
| struct tm mStandardDateUtc; |
| struct tm mDaylightDateUtc; |
| long mStandardOffset; |
| long mDaylightOffset; |
| int mCurrentYear; |
| int mAndroidTimeZoneInit; |
| std::string mTimeZoneName; |
| static const int kSecondsPerDay = 60 * 60 * 24; |
| long getTimeZoneDiff(const time_t& timeNow); |
| |
| /* |
| * Return 1 if current timezone is in daylight saving, |
| * 0 if current timezone is NOT in daylight saving. |
| * -1 if current timezone does NOT have daylight saving |
| * */ |
| int getIsDaylightSavingTime(const time_t& timeNow); |
| |
| /* |
| * Return 1 if struct tm a is bigger than struct tm b |
| * 0 if equal |
| * -1 if struct tm a is less than struct tm b |
| * */ |
| static int utcCompare(const struct tm& tm1, const struct tm& tm2); |
| |
| /* |
| * Return the struct tm difference in seconds assuming the diff is within 24 hours and |
| * |end| and |beginning| represent utc time. |
| * */ |
| static long diffTime(const struct tm& end,const struct tm& beginning); |
| #ifdef _WIN32 |
| static void parseSystemTime(const SYSTEMTIME& winTime, struct tm* androidTime); |
| |
| /* |
| * Translate tzid to windows timezone name. Then retrieve time zone |
| * information from registry. Does NOT work on WINE. |
| * */ |
| static int parseTimeZoneInformationFromRegistry(const char* winName, TIME_ZONE_INFORMATION* tzi); |
| #else // !_WIN32 |
| |
| /* |
| * Sample format: Mar 13 07:00:00 2016 and the input needs to be tokenized beforehand |
| * */ |
| static int parseZdumpDate(const std::vector<std::string>& tokens, struct tm* date); |
| |
| /* |
| * Run sample shell cmd: zdump -v America/New_York | grep 2016 to retrive timezone information |
| * Sample Output: |
| * America/New_York Sun Mar 13 06:59:59 2016 UT = Sun Mar 13 01:59:59 2016 EST isdst=0 [gmtoff=-18000] |
| * America/New_York Sun Mar 13 07:00:00 2016 UT = Sun Mar 13 03:00:00 2016 EDT isdst=1 [gmtoff=-14400] |
| * America/New_York Sun Nov 6 05:59:59 2016 UT = Sun Nov 6 01:59:59 2016 EDT isdst=1 [gmtoff=-14400] |
| * America/New_York Sun Nov 6 06:00:00 2016 UT = Sun Nov 6 01:00:00 2016 EST isdst=0 [gmtoff=-18000] |
| * |
| * Caution: gmtoff is not shown on darwin. |
| * Return 0 if the timezone is found and has daylight saving given the current |
| * year. Otherwise return -1 |
| * */ |
| int setAndroidTimeZoneUsingZdump(); |
| |
| /* |
| * Run sample shell cmd: TZ=America/New_York date +%:z to retrive timezone information |
| * Sample output: -0400 |
| * |
| * Assuming that the timezone doesn't have daylight saving, |
| * Return 0 if the timezone is found otherwise return -1. |
| * */ |
| int setAndroidTimeZoneUsingDate(); |
| #endif |
| }; |
| |
| TimeZone::TimeZone(){ |
| time_t timeNow = time(NULL); |
| //initialize the current |
| mCurrentYear = gmtime(&timeNow)->tm_year + 1900; |
| mAndroidTimeZoneInit = 0; |
| } |
| |
| long TimeZone::androidTimeZoneOffset(const time_t& timeNow) |
| { |
| if (this->mAndroidTimeZoneInit) { |
| //reset android timezone if year has changed |
| int year = gmtime(&timeNow)->tm_year + 1900; |
| if (year != mCurrentYear){ |
| mCurrentYear = year; |
| androidTimeZoneSet(mTimeZoneName.c_str()); |
| } |
| return getTimeZoneDiff(timeNow); |
| } else { |
| struct tm local = *localtime(&timeNow); |
| struct tm utc = *gmtime(&timeNow); |
| return this->diffTime(local, utc); |
| } |
| } |
| |
| struct tm* TimeZone::androidLocaltime(const time_t& timeNow) |
| { |
| if (this->mAndroidTimeZoneInit) { |
| //reset android timezone if year has changed |
| int year = gmtime(&timeNow)->tm_year + 1900; |
| if (year != mCurrentYear) { |
| mCurrentYear = year; |
| androidTimeZoneSet(mTimeZoneName.c_str()); |
| } |
| |
| int isdst = getIsDaylightSavingTime(timeNow); |
| long tzdiff = getTimeZoneDiff(timeNow); |
| time_t localTime = timeNow + tzdiff; |
| struct tm* local = NULL; |
| local = gmtime(&localTime); |
| local->tm_isdst = isdst; |
| return local; |
| } else { |
| return localtime(&timeNow); |
| } |
| } |
| |
| int TimeZone::utcCompare(const struct tm& utc1, const struct tm& utc2) |
| { |
| if (utc1.tm_year > utc2.tm_year) { |
| return 1; |
| } else if (utc1.tm_year < utc2.tm_year) { |
| return -1; |
| } else { |
| if (utc1.tm_mon > utc2.tm_mon) { |
| return 1; |
| } else if (utc1.tm_mon < utc2.tm_mon) { |
| return -1; |
| } else { |
| if (utc1.tm_mday > utc2.tm_mday) { |
| return 1; |
| } else if (utc1.tm_mday < utc2.tm_mday) { |
| return -1; |
| } else { |
| if (utc1.tm_hour > utc2.tm_hour) { |
| return 1; |
| } else if (utc1.tm_hour < utc2.tm_hour) { |
| return -1; |
| } else { |
| if (utc1.tm_min > utc2.tm_min) { |
| return 1; |
| } else if (utc1.tm_min < utc2.tm_min) { |
| return -1; |
| } else { |
| if (utc1.tm_sec > utc2.tm_sec) { |
| return 1; |
| } else if (utc1.tm_sec < utc2.tm_sec) { |
| return -1; |
| } else { |
| return 0; |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| int TimeZone::getIsDaylightSavingTime(const time_t& timeNow) |
| { |
| if (mDaylightOffset == 0) { |
| return -1; |
| } else { |
| struct tm utc = *gmtime(&timeNow); |
| if (utcCompare(utc, mStandardDateUtc) < 0 || utcCompare(utc, mDaylightDateUtc) >= 0) { |
| return 0; |
| } else { |
| return 1; |
| } |
| } |
| } |
| |
| long TimeZone::getTimeZoneDiff(const time_t& timeNow) |
| { |
| int isdst = getIsDaylightSavingTime(timeNow); |
| return (isdst <= 0) ? mStandardOffset : mStandardOffset + mDaylightOffset; |
| } |
| |
| long TimeZone::diffTime(const struct tm& end, const struct tm& beginning) |
| { |
| long endInSecs = end.tm_sec + 60 * (end.tm_min + 60 * end.tm_hour); |
| long beginningInSecs = beginning.tm_sec + 60 * (beginning.tm_min + 60 * beginning.tm_hour); |
| if (end.tm_year > beginning.tm_year) { |
| endInSecs += kSecondsPerDay; |
| } else if (end.tm_year < beginning.tm_year) { |
| beginningInSecs += kSecondsPerDay; |
| } else { |
| if (end.tm_mon > beginning.tm_mon) { |
| endInSecs += kSecondsPerDay; |
| } else if (end.tm_mon < beginning.tm_mon) { |
| beginningInSecs += kSecondsPerDay; |
| } else { |
| endInSecs += kSecondsPerDay * end.tm_mday; |
| beginningInSecs += kSecondsPerDay * beginning.tm_mday; |
| } |
| } |
| |
| return endInSecs - beginningInSecs; |
| } |
| |
| #ifdef _WIN32 |
| /* Struct referenced from https://msdn.microsoft.com/en-us/library/windows/desktop/ms725481(v=vs.85).aspx */ |
| typedef struct _REG_TZI_FORMAT |
| { |
| LONG Bias; |
| LONG StandardBias; |
| LONG DaylightBias; |
| SYSTEMTIME StandardDate; |
| SYSTEMTIME DaylightDate; |
| }REG_TZI_FORMAT; |
| |
| int TimeZone::parseTimeZoneInformationFromRegistry(const char* winName, TIME_ZONE_INFORMATION* tzi) |
| { |
| using namespace android::base; |
| using android::base::ScopedRegKey; |
| using android::base::Win32Utils; |
| HKEY hkey = 0; |
| std::string registryPath = StringFormat("SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\%s", winName); |
| |
| LONG result = RegOpenKeyEx( |
| HKEY_LOCAL_MACHINE, |
| registryPath.c_str(), |
| 0, |
| KEY_READ, |
| &hkey); |
| |
| if (result != ERROR_SUCCESS) { |
| std::string errorString = Win32Utils::getErrorString(result); |
| D( "RegOpenKeyEx failed %li %s\n", result, errorString.c_str()); |
| return -1; |
| } |
| |
| REG_TZI_FORMAT binaryTzi; |
| DWORD dataType; |
| DWORD len = sizeof(binaryTzi); |
| ScopedRegKey timezoneKey(hkey); |
| |
| result = RegQueryValueEx( |
| timezoneKey.get(), |
| "TZI", |
| NULL, |
| &dataType, |
| (LPBYTE) &binaryTzi, |
| &len); |
| |
| if (result != ERROR_SUCCESS || dataType != REG_BINARY) { |
| std::string errorString = Win32Utils::getErrorString(result); |
| D( "RegQueryValueEx failed %li %s\n", result, errorString.c_str()); |
| return -1; |
| } |
| tzi->Bias = binaryTzi.Bias; |
| tzi->DaylightBias = binaryTzi.DaylightBias; |
| tzi->DaylightDate = binaryTzi.DaylightDate; |
| tzi->StandardBias = binaryTzi.StandardBias; |
| tzi->StandardDate = binaryTzi.StandardDate; |
| |
| return 0; |
| } |
| |
| void TimeZone::parseSystemTime(const SYSTEMTIME& winTime, struct tm* androidTime) |
| { |
| androidTime->tm_year = (int)winTime.wYear - 1900; |
| androidTime->tm_mon = (int)winTime.wMonth - 1; |
| androidTime->tm_mday = (int)winTime.wDay; |
| androidTime->tm_hour = (int)winTime.wHour; |
| androidTime->tm_min = (int)winTime.wMinute; |
| androidTime->tm_sec = (int)winTime.wSecond; |
| } |
| |
| #else |
| |
| int TimeZone::parseZdumpDate(const std::vector<std::string>& tokens, struct tm* date) |
| { |
| if (tokens.size() >= 4) { |
| int monIdx = -1; |
| for(int i = 0; i < 12; i++) { |
| if (!tokens[0].compare(kMonthName[i])) { |
| monIdx = i; |
| break; |
| } |
| } |
| if (monIdx == -1) { return -1; } |
| |
| date->tm_mon = monIdx; |
| date->tm_mday = std::stoi(tokens[1]); |
| date->tm_hour = std::stoi(tokens[2].substr(0,2)); |
| date->tm_min = std::stoi(tokens[2].substr(3, 2)); |
| date->tm_sec = std::stoi(tokens[2].substr(6,2)); |
| date->tm_year = std::stoi(tokens[3]) - 1900; |
| return 0; |
| } |
| else { |
| return -1; |
| } |
| } |
| |
| int TimeZone::setAndroidTimeZoneUsingZdump() |
| { |
| using namespace android::base; |
| std::string zdumpCmd = StringFormat( |
| "zdump -v %s | grep %d", mTimeZoneName, mCurrentYear); |
| std::vector<std::string> shellCmd = {"/bin/bash", "-c", std::move(zdumpCmd)}; |
| RunOptions runFlags = System::RunOptions::WaitForCompletion | |
| System::RunOptions::TerminateOnTimeout | |
| System::RunOptions::DumpOutputToFile; |
| System::Duration timeout = 1000; |
| System::ProcessExitCode exitCode; |
| const std::string outputFile = PathUtils::join( |
| System::get()->getTempDir(), |
| StringFormat("android_tzoffset%d", |
| (int)System::get()->getCurrentProcessId())); |
| |
| bool commandRan = System::get()->runCommand( |
| shellCmd, runFlags, timeout, &exitCode, nullptr, outputFile); |
| |
| if (commandRan && !exitCode) { |
| std::ifstream file(outputFile.c_str()); |
| std::string line; |
| std::vector<std::string> rules; |
| while (std::getline(file, line)) { |
| rules.push_back(std::move(line)); |
| } |
| long utcOffsetDST = 0; |
| long utcOffsetStandard = 0; |
| if (rules.size() == 4) { |
| //tokenize only the 2nd and 4th rule |
| for(int i = 1; i < 4; i += 2) { |
| std::stringstream ss(rules[i]); |
| std::vector<std::string> tokens; |
| std::string token; |
| while (ss >> token) { |
| tokens.push_back(std::move(token)); |
| } |
| std::vector<std::string> utcTokens(tokens.begin() + 2, tokens.begin() + 6); |
| if (parseZdumpDate(utcTokens, i == 1 ? &mStandardDateUtc : &mDaylightDateUtc)) { |
| return -1; |
| } |
| struct tm localDate; |
| std::vector<std::string> localTokens(tokens.begin() + 9, tokens.begin() + 13); |
| if (parseZdumpDate(localTokens, &localDate)) { |
| return -1; |
| } |
| if (i == 1) { |
| utcOffsetDST = this->diffTime(localDate, mStandardDateUtc); |
| } else { |
| utcOffsetStandard = this->diffTime(localDate, mDaylightDateUtc); |
| } |
| } |
| mStandardOffset = utcOffsetStandard; |
| mDaylightOffset = utcOffsetDST - utcOffsetStandard; |
| return 0; |
| } |
| } |
| return -1; |
| } |
| |
| int TimeZone::setAndroidTimeZoneUsingDate() |
| { |
| using namespace android::base; |
| std::string dateCmd = StringFormat("TZ=%s date +%%z", mTimeZoneName.c_str()); |
| std::vector<std::string> shellCmd = {"/bin/bash", "-c", std::move(dateCmd)}; |
| RunOptions runFlags = System::RunOptions::WaitForCompletion | |
| System::RunOptions::TerminateOnTimeout | |
| System::RunOptions::DumpOutputToFile; |
| System::Duration timeout = 1000; |
| System::ProcessExitCode exitCode; |
| const std::string outputFile = PathUtils::join( |
| System::get()->getTempDir(), |
| StringFormat("android_tzoffset%d", |
| (int)System::get()->getCurrentProcessId())); |
| |
| bool commandRan = System::get()->runCommand( |
| shellCmd, runFlags, timeout, &exitCode, nullptr, outputFile); |
| |
| if (commandRan && !exitCode) { |
| std::ifstream file(outputFile.c_str()); |
| std::string tzdiff; |
| std::getline(file, tzdiff); |
| file.close(); |
| int sign = (tzdiff[0] == '+') ? 1 : -1; |
| mStandardOffset = sign * (60 * (std::stoi(tzdiff.substr(1, 2)) * 60 + std::stoi(tzdiff.substr(3,2)))); |
| mDaylightOffset = 0; |
| return 0; |
| } else { |
| return -1; |
| } |
| } |
| |
| #endif |
| |
| int TimeZone::androidTimeZoneSet(const char* tzname) |
| { |
| mTimeZoneName = std::string(tzname); |
| this->mAndroidTimeZoneInit = 0; |
| #ifdef _WIN32 |
| const char* winName = NULL; |
| for (const Win32Timezone* win32tz = _win32_timezones; win32tz->win_name != NULL; win32tz++) { |
| if (!strcmp(win32tz->zoneinfo_name, tzname)) { |
| winName = win32tz->win_name; |
| break; |
| } |
| } |
| |
| if (winName) { |
| TIME_ZONE_INFORMATION win_tzi; |
| if (parseTimeZoneInformationFromRegistry(winName, &win_tzi)) { |
| D( "%s: could not retrieve time zone information from registry on Windows, use host localtime by default.\n", __FUNCTION__ ); |
| } else { |
| //UTC = localtime + Bias |
| mStandardOffset = -win_tzi.StandardBias * 60; |
| mDaylightOffset = -win_tzi.DaylightBias * 60; |
| if (mDaylightOffset != 0) { |
| parseSystemTime(win_tzi.StandardDate, &mStandardDateUtc); |
| parseSystemTime(win_tzi.DaylightDate, &mStandardDateUtc); |
| } |
| this->mAndroidTimeZoneInit = 1; |
| } |
| } else { |
| D( "%s: could not determine current timezone\n", __FUNCTION__ ); |
| } |
| #else |
| if (setAndroidTimeZoneUsingZdump() && setAndroidTimeZoneUsingDate()) { |
| D( "%s: could not retrieve time zone information from zdump or date " |
| "command, use host localtime by default.\n", __func__); |
| } else { |
| this->mAndroidTimeZoneInit = 1; |
| } |
| #endif |
| return this->mAndroidTimeZoneInit ? 0 : -1; |
| } |
| |
| android::base::LazyInstance<TimeZone> sAndroidTimeZone = LAZY_INSTANCE_INIT; |
| |
| } //namespace |
| |
| int |
| timezone_set(const char *tzname) |
| { |
| int len; |
| android_timezone_init = 0; |
| if (!check_timezone_is_zoneinfo(tzname)){ return -1; } |
| len = strlen(tzname); |
| if (len > (int)sizeof(android_timezone0)-1) { return -1; } |
| strcpy(android_timezone0, tzname); |
| android_timezone = android_timezone0; |
| if (sAndroidTimeZone->androidTimeZoneSet(tzname)) { |
| return -1; |
| } else { |
| android_timezone_init = 1; |
| return 0; |
| } |
| } |
| |
| long |
| android_tzoffset_in_seconds(time_t* time_p) |
| { |
| time_t time = *time_p; |
| return sAndroidTimeZone->androidTimeZoneOffset(time); |
| } |
| |
| struct tm* android_localtime(time_t* time_p) |
| { |
| time_t time = *time_p; |
| return sAndroidTimeZone->androidLocaltime(time); |
| } |
