icuSources/common/wintz.c

   1 /*
   2 ********************************************************************************
   3 *   Copyright (C) 2005-2013, International Business Machines
   4 *   Corporation and others.  All Rights Reserved.
   5 ********************************************************************************
   6 *
   7 * File WINTZ.CPP
   8 *
   9 ********************************************************************************
  10 */
  11
  12 #include "unicode/utypes.h"
  13
  14 #if U_PLATFORM_HAS_WIN32_API
  15
  16 #include "wintz.h"
  17 #include "cmemory.h"
  18 #include "cstring.h"
  19
  20 #include "unicode/ures.h"
  21
  22 #   define WIN32_LEAN_AND_MEAN
  23 #   define VC_EXTRALEAN
  24 #   define NOUSER
  25 #   define NOSERVICE
  26 #   define NOIME
  27 #   define NOMCX
  28 #include <windows.h>
  29
  30 #define MAX_LENGTH_ID 40
  31
  32 /* The layout of the Tzi value in the registry */
  33 typedef struct
  34 {
  35     int32_t bias;
  36     int32_t standardBias;
  37     int32_t daylightBias;
  38     SYSTEMTIME standardDate;
  39     SYSTEMTIME daylightDate;
  40 } TZI;
  41
  42 /**
  43  * Various registry keys and key fragments.
  44  */
  45 static const char CURRENT_ZONE_REGKEY[] = "SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation\\";
  46 static const char STANDARD_NAME_REGKEY[] = "StandardName";
  47 static const char STANDARD_TIME_REGKEY[] = " Standard Time";
  48 static const char TZI_REGKEY[] = "TZI";
  49 static const char STD_REGKEY[] = "Std";
  50
  51 /**
  52  * HKLM subkeys used to probe for the flavor of Windows.  Note that we
  53  * specifically check for the "GMT" zone subkey; this is present on
  54  * NT, but on XP has become "GMT Standard Time".  We need to
  55  * discriminate between these cases.
  56  */
  57 static const char* const WIN_TYPE_PROBE_REGKEY[] = {
  58     /* WIN_9X_ME_TYPE */
  59     "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Time Zones",
  60
  61     /* WIN_NT_TYPE */
  62     "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\GMT"
  63
  64     /* otherwise: WIN_2K_XP_TYPE */
  65 };
  66
  67 /**
  68  * The time zone root subkeys (under HKLM) for different flavors of
  69  * Windows.
  70  */
  71 static const char* const TZ_REGKEY[] = {
  72     /* WIN_9X_ME_TYPE */
  73     "SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Time Zones\\",
  74
  75     /* WIN_NT_TYPE | WIN_2K_XP_TYPE */
  76     "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\"
  77 };
  78
  79 /**
  80  * Flavor of Windows, from our perspective.  Not a real OS version,
  81  * but rather the flavor of the layout of the time zone information in
  82  * the registry.
  83  */
  84 enum {
  85     WIN_9X_ME_TYPE = 1,
  86     WIN_NT_TYPE = 2,
  87     WIN_2K_XP_TYPE = 3
  88 };
  89
  90 static int32_t gWinType = 0;
  91
  92 static int32_t detectWindowsType()
  93 {
  94     int32_t winType;
  95     LONG result;
  96     HKEY hkey;
  97
  98     /* Detect the version of windows by trying to open a sequence of
  99         probe keys.  We don't use the OS version API because what we
 100         really want to know is how the registry is laid out.
 101         Specifically, is it 9x/Me or not, and is it "GMT" or "GMT
 102         Standard Time". */
 103     for (winType = 0; winType < 2; winType++) {
 104         result = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 105                               WIN_TYPE_PROBE_REGKEY[winType],
 106                               0,
 107                               KEY_QUERY_VALUE,
 108                               &hkey);
 109         RegCloseKey(hkey);
 110
 111         if (result == ERROR_SUCCESS) {
 112             break;
 113         }
 114     }
 115
 116     return winType+1; /* +1 to bring it inline with the enum */
 117 }
 118
 119 static LONG openTZRegKey(HKEY *hkey, const char *winid)
 120 {
 121     /* subKeyName needs to be long enough for the longest TZ_REGKEY, plus the longest Windows
 122      * tzid (current or obsolete), plus an appended STANDARD_TIME_REGKEY, plus a 0 terminator.
 123      * At its max point this was 111, but the code had 110. Make it 128 for some wiggle room. */
 124     char subKeyName[128];
 125     char *name;
 126     LONG result;
 127
 128     /* This isn't thread safe, but it's good enough because the result should be constant per system. */
 129     if (gWinType <= 0) {
 130         gWinType = detectWindowsType();
 131     }
 132
 133     uprv_strcpy(subKeyName, TZ_REGKEY[(gWinType != WIN_9X_ME_TYPE)]);
 134     name = &subKeyName[strlen(subKeyName)];
 135     uprv_strcat(subKeyName, winid);
 136
 137     if (gWinType == WIN_9X_ME_TYPE) {
 138         /* Remove " Standard Time" */
 139         char *pStd = uprv_strstr(subKeyName, STANDARD_TIME_REGKEY);
 140         if (pStd) {
 141             *pStd = 0;
 142         }
 143     }
 144
 145     result = RegOpenKeyExA(HKEY_LOCAL_MACHINE,
 146                             subKeyName,
 147                             0,
 148                             KEY_QUERY_VALUE,
 149                             hkey);
 150     return result;
 151 }
 152
 153 static LONG getTZI(const char *winid, TZI *tzi)
 154 {
 155     DWORD cbData = sizeof(TZI);
 156     LONG result;
 157     HKEY hkey;
 158
 159     result = openTZRegKey(&hkey, winid);
 160
 161     if (result == ERROR_SUCCESS) {
 162         result = RegQueryValueExA(hkey,
 163                                     TZI_REGKEY,
 164                                     NULL,
 165                                     NULL,
 166                                     (LPBYTE)tzi,
 167                                     &cbData);
 168
 169     }
 170
 171     RegCloseKey(hkey);
 172
 173     return result;
 174 }
 175
 176 static LONG getSTDName(const char *winid, char *regStdName, int32_t length) {
 177     DWORD cbData = length;
 178     LONG result;
 179     HKEY hkey;
 180
 181     result = openTZRegKey(&hkey, winid);
 182
 183     if (result == ERROR_SUCCESS) {
 184         result = RegQueryValueExA(hkey,
 185                                     STD_REGKEY,
 186                                     NULL,
 187                                     NULL,
 188                                     (LPBYTE)regStdName,
 189                                     &cbData);
 190
 191     }
 192
 193     RegCloseKey(hkey);
 194
 195     return result;
 196 }
 197
 198 /*
 199   This code attempts to detect the Windows time zone, as set in the
 200   Windows Date and Time control panel.  It attempts to work on
 201   multiple flavors of Windows (9x, Me, NT, 2000, XP) and on localized
 202   installs.  It works by directly interrogating the registry and
 203   comparing the data there with the data returned by the
 204   GetTimeZoneInformation API, along with some other strategies.  The
 205   registry contains time zone data under one of two keys (depending on
 206   the flavor of Windows):
 207
 208     HKLM\SOFTWARE\Microsoft\Windows\CurrentVersion\Time Zones\
 209     HKLM\SOFTWARE\Microsoft\Windows NT\CurrentVersion\Time Zones\
 210
 211   Under this key are several subkeys, one for each time zone.  These
 212   subkeys are named "Pacific" on Win9x/Me and "Pacific Standard Time"
 213   on WinNT/2k/XP.  There are some other wrinkles; see the code for
 214   details.  The subkey name is NOT LOCALIZED, allowing us to support
 215   localized installs.
 216
 217   Under the subkey are data values.  We care about:
 218
 219     Std   Standard time display name, localized
 220     TZI   Binary block of data
 221
 222   The TZI data is of particular interest.  It contains the offset, two
 223   more offsets for standard and daylight time, and the start and end
 224   rules.  This is the same data returned by the GetTimeZoneInformation
 225   API.  The API may modify the data on the way out, so we have to be
 226   careful, but essentially we do a binary comparison against the TZI
 227   blocks of various registry keys.  When we find a match, we know what
 228   time zone Windows is set to.  Since the registry key is not
 229   localized, we can then translate the key through a simple table
 230   lookup into the corresponding ICU time zone.
 231
 232   This strategy doesn't always work because there are zones which
 233   share an offset and rules, so more than one TZI block will match.
 234   For example, both Tokyo and Seoul are at GMT+9 with no DST rules;
 235   their TZI blocks are identical.  For these cases, we fall back to a
 236   name lookup.  We attempt to match the display name as stored in the
 237   registry for the current zone to the display name stored in the
 238   registry for various Windows zones.  By comparing the registry data
 239   directly we avoid conversion complications.
 240
 241   Author: Alan Liu
 242   Since: ICU 2.6
 243   Based on original code by Carl Brown <cbrown@xnetinc.com>
 244 */
 245
 246 /**
 247  * Main Windows time zone detection function.  Returns the Windows
 248  * time zone, translated to an ICU time zone, or NULL upon failure.
 249  */
 250 U_CFUNC const char* U_EXPORT2
 251 uprv_detectWindowsTimeZone() {
 252     UErrorCode status = U_ZERO_ERROR;
 253     UResourceBundle* bundle = NULL;
 254     char* icuid = NULL;
 255     char apiStdName[MAX_LENGTH_ID];
 256     char regStdName[MAX_LENGTH_ID];
 257     char tmpid[MAX_LENGTH_ID];
 258     int32_t len;
 259     int id;
 260     int errorCode;
 261     char ISOcode[3]; /* 2 letter iso code */
 262
 263     LONG result;
 264     TZI tziKey;
 265     TZI tziReg;
 266     TIME_ZONE_INFORMATION apiTZI;
 267
 268     /* Obtain TIME_ZONE_INFORMATION from the API, and then convert it
 269        to TZI.  We could also interrogate the registry directly; we do
 270        this below if needed. */
 271     uprv_memset(&apiTZI, 0, sizeof(apiTZI));
 272     uprv_memset(&tziKey, 0, sizeof(tziKey));
 273     uprv_memset(&tziReg, 0, sizeof(tziReg));
 274     GetTimeZoneInformation(&apiTZI);
 275     tziKey.bias = apiTZI.Bias;
 276     uprv_memcpy((char *)&tziKey.standardDate, (char*)&apiTZI.StandardDate,
 277            sizeof(apiTZI.StandardDate));
 278     uprv_memcpy((char *)&tziKey.daylightDate, (char*)&apiTZI.DaylightDate,
 279            sizeof(apiTZI.DaylightDate));
 280
 281     /* Convert the wchar_t* standard name to char* */
 282     uprv_memset(apiStdName, 0, sizeof(apiStdName));
 283     wcstombs(apiStdName, apiTZI.StandardName, MAX_LENGTH_ID);
 284
 285     tmpid[0] = 0;
 286
 287     id = GetUserGeoID(GEOCLASS_NATION);
 288     errorCode = GetGeoInfo(id,GEO_ISO2,ISOcode,3,0);
 289
 290     bundle = ures_openDirect(NULL, "windowsZones", &status);
 291     ures_getByKey(bundle, "mapTimezones", bundle, &status);
 292
 293     /* Note: We get the winid not from static tables but from resource bundle. */
 294     while (U_SUCCESS(status) && ures_hasNext(bundle)) {
 295         UBool idFound = FALSE;
 296         const char* winid;
 297         UResourceBundle* winTZ = ures_getNextResource(bundle, NULL, &status);
 298         if (U_FAILURE(status)) {
 299             break;
 300         }
 301         winid = ures_getKey(winTZ);
 302         result = getTZI(winid, &tziReg);
 303
 304         if (result == ERROR_SUCCESS) {
 305             /* Windows alters the DaylightBias in some situations.
 306                Using the bias and the rules suffices, so overwrite
 307                these unreliable fields. */
 308             tziKey.standardBias = tziReg.standardBias;
 309             tziKey.daylightBias = tziReg.daylightBias;
 310
 311             if (uprv_memcmp((char *)&tziKey, (char*)&tziReg, sizeof(tziKey)) == 0) {
 312                 const UChar* icuTZ = NULL;
 313                 if (errorCode != 0) {
 314                     icuTZ = ures_getStringByKey(winTZ, ISOcode, &len, &status);
 315                 }
 316                 if (errorCode==0 || icuTZ==NULL) {
 317                     /* fallback to default "001" and reset status */
 318                     status = U_ZERO_ERROR;
 319                     icuTZ = ures_getStringByKey(winTZ, "001", &len, &status);
 320                 }
 321
 322                 if (U_SUCCESS(status)) {
 323                     /* Get the standard name from the registry key to compare with
 324                        the one from Windows API call. */
 325                     uprv_memset(regStdName, 0, sizeof(regStdName));
 326                     result = getSTDName(winid, regStdName, sizeof(regStdName));
 327                     if (result == ERROR_SUCCESS) {
 328                         if (uprv_strcmp(apiStdName, regStdName) == 0) {
 329                             idFound = TRUE;
 330                         }
 331                     }
 332
 333                     /* tmpid buffer holds the ICU timezone ID corresponding to the timezone ID from Windows.
 334                      * If none is found, tmpid buffer will contain a fallback ID (i.e. the time zone ID matching
 335                      * the current time zone information)
 336                      */
 337                     if (idFound || tmpid[0] == 0) {
 338                         /* if icuTZ has more than one city, take only the first (i.e. terminate icuTZ at first space) */
 339                         int index=0;
 340                         while (! (*icuTZ == '\0' || *icuTZ ==' ')) {
 341                             tmpid[index++]=(char)(*icuTZ++);  /* safe to assume 'char' is ASCII compatible on windows */
 342                         }
 343                         tmpid[index]='\0';
 344                     }
 345                 }
 346             }
 347         }
 348         ures_close(winTZ);
 349         if (idFound) {
 350             break;
 351         }
 352     }
 353
 354     /*
 355      * Copy the timezone ID to icuid to be returned.
 356      */
 357     if (tmpid[0] != 0) {
 358         len = uprv_strlen(tmpid);
 359         icuid = (char*)uprv_calloc(len + 1, sizeof(char));
 360         if (icuid != NULL) {
 361             uprv_strcpy(icuid, tmpid);
 362         }
 363     }
 364
 365     ures_close(bundle);
 366
 367     return icuid;
 368 }
 369
 370 #endif /* U_PLATFORM_HAS_WIN32_API */