CFTimeZone.c

   1 /*
   2  * Copyright (c) 2009 Apple Inc. All rights reserved.
   3  *
   4  * @APPLE_LICENSE_HEADER_START@
   5  *
   6  * This file contains Original Code and/or Modifications of Original Code
   7  * as defined in and that are subject to the Apple Public Source License
   8  * Version 2.0 (the 'License'). You may not use this file except in
   9  * compliance with the License. Please obtain a copy of the License at
  10  * http://www.opensource.apple.com/apsl/ and read it before using this
  11  * file.
  12  *
  13  * The Original Code and all software distributed under the License are
  14  * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
  15  * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
  16  * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
  17  * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
  18  * Please see the License for the specific language governing rights and
  19  * limitations under the License.
  20  *
  21  * @APPLE_LICENSE_HEADER_END@
  22  */
  23
  24 /*      CFTimeZone.c
  25         Copyright 1998-2002, Apple, Inc. All rights reserved.
  26         Responsibility: Christopher Kane
  27 */
  28
  29
  30
  31 #include <CoreFoundation/CFTimeZone.h>
  32 #include <CoreFoundation/CFPropertyList.h>
  33 #include <CoreFoundation/CFDateFormatter.h>
  34 #include <CoreFoundation/CFPriv.h>
  35 #include "CFInternal.h"
  36 #include <math.h>
  37 #include <limits.h>
  38 #include <sys/stat.h>
  39 #include <fcntl.h>
  40 #include <stdlib.h>
  41 #include <string.h>
  42 #include <unicode/ucal.h>
  43 #include <CoreFoundation/CFDateFormatter.h>
  44 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS
  45 #include <dirent.h>
  46 #include <unistd.h>
  47 #include <sys/fcntl.h>
  48 #include <tzfile.h>
  49 #else
  50 #error Unknown or unspecified DEPLOYMENT_TARGET
  51 #endif
  52
  53
  54 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
  55 #define TZZONELINK      TZDEFAULT
  56 #define TZZONEINFO      TZDIR "/"
  57 #elif DEPLOYMENT_TARGET_WINDOWS
  58 static CFStringRef __tzZoneInfo = NULL;
  59 static char *__tzDir = NULL;
  60 static void __InitTZStrings(void);
  61 #else
  62 #error Unknown or unspecified DEPLOYMENT_TARGET
  63 #endif
  64
  65 CONST_STRING_DECL(kCFTimeZoneSystemTimeZoneDidChangeNotification, "kCFTimeZoneSystemTimeZoneDidChangeNotification")
  66
  67 static CFTimeZoneRef __CFTimeZoneSystem = NULL;
  68 static CFTimeZoneRef __CFTimeZoneDefault = NULL;
  69 static CFDictionaryRef __CFTimeZoneAbbreviationDict = NULL;
  70 static CFSpinLock_t __CFTimeZoneAbbreviationLock = CFSpinLockInit;
  71 static CFMutableDictionaryRef __CFTimeZoneCompatibilityMappingDict = NULL;
  72 static CFSpinLock_t __CFTimeZoneCompatibilityMappingLock = CFSpinLockInit;
  73 static CFArrayRef __CFKnownTimeZoneList = NULL;
  74 static CFMutableDictionaryRef __CFTimeZoneCache = NULL;
  75 static CFSpinLock_t __CFTimeZoneGlobalLock = CFSpinLockInit;
  76
  77 #if DEPLOYMENT_TARGET_WINDOWS
  78 static CFDictionaryRef __CFTimeZoneWinToOlsonDict = NULL;
  79 static CFSpinLock_t __CFTimeZoneWinToOlsonLock = CFSpinLockInit;
  80 #endif
  81
  82 CF_INLINE void __CFTimeZoneLockGlobal(void) {
  83     __CFSpinLock(&__CFTimeZoneGlobalLock);
  84 }
  85
  86 CF_INLINE void __CFTimeZoneUnlockGlobal(void) {
  87     __CFSpinUnlock(&__CFTimeZoneGlobalLock);
  88 }
  89
  90 CF_INLINE void __CFTimeZoneLockAbbreviations(void) {
  91     __CFSpinLock(&__CFTimeZoneAbbreviationLock);
  92 }
  93
  94 CF_INLINE void __CFTimeZoneUnlockAbbreviations(void) {
  95     __CFSpinUnlock(&__CFTimeZoneAbbreviationLock);
  96 }
  97
  98 CF_INLINE void __CFTimeZoneLockCompatibilityMapping(void) {
  99     __CFSpinLock(&__CFTimeZoneCompatibilityMappingLock);
 100 }
 101
 102 CF_INLINE void __CFTimeZoneUnlockCompatibilityMapping(void) {
 103     __CFSpinUnlock(&__CFTimeZoneCompatibilityMappingLock);
 104 }
 105
 106 #if DEPLOYMENT_TARGET_WINDOWS
 107 /* This function should be used for WIN32 instead of
 108  * __CFCopyRecursiveDirectoryList function.
 109  * It takes TimeZone names from the registry
 110  * (Aleksey Dukhnyakov)
 111  */
 112 static CFMutableArrayRef __CFCopyWindowsTimeZoneList() {
 113     CFMutableArrayRef result = NULL;
 114     HKEY hkResult;
 115     TCHAR lpName[MAX_PATH+1];
 116     DWORD dwIndex, retCode;
 117
 118     if (RegOpenKey(HKEY_LOCAL_MACHINE,_T(TZZONEINFO),&hkResult) !=
 119         ERROR_SUCCESS )
 120         return NULL;
 121
 122     result = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeArrayCallBacks);
 123     for (dwIndex=0; (retCode = RegEnumKey(hkResult,dwIndex,lpName,MAX_PATH)) != ERROR_NO_MORE_ITEMS ; dwIndex++) {
 124         if (retCode != ERROR_SUCCESS) {
 125             RegCloseKey(hkResult);
 126             CFRelease(result);
 127             return NULL;
 128         } else {
 129 #if defined(UNICODE)
 130             CFStringRef string = CFStringCreateWithBytes(kCFAllocatorSystemDefault, (const UInt8 *)lpName, (_tcslen(lpName) * sizeof(UniChar)), kCFStringEncodingUnicode, false);
 131 #else
 132             CFStringRef string = CFStringCreateWithBytes(kCFAllocatorSystemDefault, lpName, _tcslen(lpName), CFStringGetSystemEncoding(), false);
 133 #endif
 134             CFArrayAppendValue(result, string);
 135             CFRelease(string);
 136         }
 137     }
 138
 139     RegCloseKey(hkResult);
 140     return result;
 141 }
 142 #elif DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED  || DEPLOYMENT_TARGET_WINDOWS
 143 static CFMutableArrayRef __CFCopyRecursiveDirectoryList() {
 144     CFMutableArrayRef result = CFArrayCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeArrayCallBacks);
 145 #if DEPLOYMENT_TARGET_WINDOWS
 146     if (!__tzDir) __InitTZStrings();
 147     if (!__tzDir) return result;
 148     int fd = open(__tzDir, O_RDONLY);
 149 #else
 150     int fd = open(TZDIR "/zone.tab", O_RDONLY);
 151 #endif
 152
 153     for (; 0 <= fd;) {
 154         uint8_t buffer[4096];
 155         ssize_t len = read(fd, buffer, sizeof(buffer));
 156         if (len <= 0) break;
 157         if (len < sizeof(buffer)) {
 158             // assumes that partial read only occurs at the end of the file
 159             buffer[len] = '\n';
 160             len++;
 161         }
 162         const uint8_t *bytes = buffer;
 163         for (;;) {
 164             const uint8_t *nextl = memchr(bytes, '\n', len);
 165             if (!nextl) break;
 166             nextl++;
 167             if ('#' == *bytes) {
 168                 len -= (nextl - bytes);
 169                 bytes = nextl;
 170                 continue;
 171             }
 172             const uint8_t *tab1 = memchr(bytes, '\t', (nextl - bytes));
 173             if (!tab1) {
 174                 len -= (nextl - bytes);
 175                 bytes = nextl;
 176                 continue;
 177             }
 178             tab1++;
 179             len -= (tab1 - bytes);
 180             bytes = tab1;
 181             const uint8_t *tab2 = memchr(bytes, '\t', (nextl - bytes));
 182             if (!tab2) {
 183                 len -= (nextl - bytes);
 184                 bytes = nextl;
 185                 continue;
 186             }
 187             tab2++;
 188             len -= (tab2 - bytes);
 189             bytes = tab2;
 190             const uint8_t *tab3 = memchr(bytes, '\t', (nextl - bytes));
 191             int nmlen = tab3 ? (tab3 - bytes) : (nextl - 1 - bytes);
 192             CFStringRef string = CFStringCreateWithBytes(kCFAllocatorSystemDefault, bytes, nmlen, kCFStringEncodingUTF8, false);
 193             CFArrayAppendValue(result, string);
 194             CFRelease(string);
 195             len -= (nextl - bytes);
 196             bytes = nextl;
 197         }
 198         lseek(fd, -len, SEEK_CUR);
 199     }
 200     close(fd);
 201     return result;
 202 }
 203 #else
 204 #error Unknown or unspecified DEPLOYMENT_TARGET
 205 #endif
 206
 207 typedef struct _CFTZPeriod {
 208     int32_t startSec;
 209     CFStringRef abbrev;
 210     uint32_t info;
 211 } CFTZPeriod;
 212
 213 struct __CFTimeZone {
 214     CFRuntimeBase _base;
 215     CFStringRef _name;          /* immutable */
 216     CFDataRef _data;            /* immutable */
 217     CFTZPeriod *_periods;       /* immutable */
 218     int32_t _periodCnt;         /* immutable */
 219 };
 220
 221 /* startSec is the whole integer seconds from a CFAbsoluteTime, giving dates
 222  * between 1933 and 2069; info outside these years is discarded on read-in */
 223 /* Bits 31-18 of the info are unused */
 224 /* Bit 17 of the info is used for the is-DST state */
 225 /* Bit 16 of the info is used for the sign of the offset (1 == negative) */
 226 /* Bits 15-0 of the info are used for abs(offset) in seconds from GMT */
 227
 228 CF_INLINE void __CFTZPeriodInit(CFTZPeriod *period, int32_t startTime, CFStringRef abbrev, int32_t offset, Boolean isDST) {
 229     period->startSec = startTime;
 230     period->abbrev = abbrev ? (CFStringRef)CFRetain(abbrev) : NULL;
 231     __CFBitfieldSetValue(period->info, 15, 0, abs(offset));
 232     __CFBitfieldSetValue(period->info, 16, 16, (offset < 0 ? 1 : 0));
 233     __CFBitfieldSetValue(period->info, 17, 17, (isDST ? 1 : 0));
 234 }
 235
 236 CF_INLINE int32_t __CFTZPeriodStartSeconds(const CFTZPeriod *period) {
 237     return period->startSec;
 238 }
 239
 240 CF_INLINE CFStringRef __CFTZPeriodAbbreviation(const CFTZPeriod *period) {
 241     return period->abbrev;
 242 }
 243
 244 CF_INLINE int32_t __CFTZPeriodGMTOffset(const CFTZPeriod *period) {
 245     int32_t v = __CFBitfieldGetValue(period->info, 15, 0);
 246     if (__CFBitfieldGetValue(period->info, 16, 16)) v = -v;
 247     return v;
 248 }
 249
 250 CF_INLINE Boolean __CFTZPeriodIsDST(const CFTZPeriod *period) {
 251     return (Boolean)__CFBitfieldGetValue(period->info, 17, 17);
 252 }
 253
 254 static CFComparisonResult __CFCompareTZPeriods(const void *val1, const void *val2, void *context) {
 255     CFTZPeriod *tzp1 = (CFTZPeriod *)val1;
 256     CFTZPeriod *tzp2 = (CFTZPeriod *)val2;
 257     // we treat equal as less than, as the code which uses the
 258     // result of the bsearch doesn't expect exact matches
 259     // (they're pretty rare, so no point in over-coding for them)
 260     if (__CFTZPeriodStartSeconds(tzp1) <= __CFTZPeriodStartSeconds(tzp2)) return kCFCompareLessThan;
 261     return kCFCompareGreaterThan;
 262 }
 263
 264 static CFIndex __CFBSearchTZPeriods(CFTimeZoneRef tz, CFAbsoluteTime at) {
 265     CFTZPeriod elem;
 266     __CFTZPeriodInit(&elem, (int32_t)floor(at + 1.0), NULL, 0, false);
 267     CFIndex idx = CFBSearch(&elem, sizeof(CFTZPeriod), tz->_periods, tz->_periodCnt, __CFCompareTZPeriods, NULL);
 268     if (tz->_periodCnt <= idx) {
 269         idx = tz->_periodCnt;
 270     } else if (0 == idx) {
 271         idx = 1;
 272     }
 273     return idx - 1;
 274 }
 275
 276
 277 CF_INLINE int32_t __CFDetzcode(const unsigned char *bufp) {
 278     int32_t result = (bufp[0] & 0x80) ? ~0L : 0L;
 279     result = (result << 8) | (bufp[0] & 0xff);
 280     result = (result << 8) | (bufp[1] & 0xff);
 281     result = (result << 8) | (bufp[2] & 0xff);
 282     result = (result << 8) | (bufp[3] & 0xff);
 283     return result;
 284 }
 285
 286 CF_INLINE void __CFEntzcode(int32_t value, unsigned char *bufp) {
 287     bufp[0] = (value >> 24) & 0xff;
 288     bufp[1] = (value >> 16) & 0xff;
 289     bufp[2] = (value >> 8) & 0xff;
 290     bufp[3] = (value >> 0) & 0xff;
 291 }
 292
 293 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
 294 static Boolean __CFParseTimeZoneData(CFAllocatorRef allocator, CFDataRef data, CFTZPeriod **tzpp, CFIndex *cntp) {
 295     int32_t len, timecnt, typecnt, charcnt, idx, cnt;
 296     const uint8_t *p, *timep, *typep, *ttisp, *charp;
 297     CFStringRef *abbrs;
 298     Boolean result = true;
 299
 300     p = CFDataGetBytePtr(data);
 301     len = CFDataGetLength(data);
 302     if (len < (int32_t)sizeof(struct tzhead)) {
 303         return false;
 304     }
 305
 306     if (!(p[0] == 'T' && p[1] == 'Z' && p[2] == 'i' && p[3] == 'f')) return false;  /* Don't parse without TZif at head of file */
 307
 308     p += 20 + 4 + 4 + 4;        /* skip reserved, ttisgmtcnt, ttisstdcnt, leapcnt */
 309     timecnt = __CFDetzcode(p);
 310     p += 4;
 311     typecnt = __CFDetzcode(p);
 312     p += 4;
 313     charcnt = __CFDetzcode(p);
 314     p += 4;
 315     if (typecnt <= 0 || timecnt < 0 || charcnt < 0) {
 316         return false;
 317     }
 318     if (1024 < timecnt || 32 < typecnt || 128 < charcnt) {
 319         // reject excessive timezones to avoid arithmetic overflows for
 320         // security reasons and to reject potentially corrupt files
 321         return false;
 322     }
 323     if (len - (int32_t)sizeof(struct tzhead) < (4 + 1) * timecnt + (4 + 1 + 1) * typecnt + charcnt) {
 324         return false;
 325     }
 326     timep = p;
 327     typep = timep + 4 * timecnt;
 328     ttisp = typep + timecnt;
 329     charp = ttisp + (4 + 1 + 1) * typecnt;
 330     cnt = (0 < timecnt) ? timecnt : 1;
 331     *tzpp = CFAllocatorAllocate(allocator, cnt * sizeof(CFTZPeriod), 0);
 332     if (__CFOASafe) __CFSetLastAllocationEventName(*tzpp, "CFTimeZone (store)");
 333     memset(*tzpp, 0, cnt * sizeof(CFTZPeriod));
 334     abbrs = CFAllocatorAllocate(allocator, (charcnt + 1) * sizeof(CFStringRef), 0);
 335     if (__CFOASafe) __CFSetLastAllocationEventName(abbrs, "CFTimeZone (temp)");
 336     for (idx = 0; idx < charcnt + 1; idx++) {
 337         abbrs[idx] = NULL;
 338     }
 339     for (idx = 0; idx < cnt; idx++) {
 340         CFAbsoluteTime at;
 341         int32_t itime, offset;
 342         uint8_t type, dst, abbridx;
 343
 344         at = (CFAbsoluteTime)(__CFDetzcode(timep) + 0.0) - kCFAbsoluteTimeIntervalSince1970;
 345         if (0 == timecnt) itime = INT_MIN;
 346         else if (at < (CFAbsoluteTime)INT_MIN) itime = INT_MIN;
 347         else if ((CFAbsoluteTime)INT_MAX < at) itime = INT_MAX;
 348         else itime = (int32_t)at;
 349         timep += 4;     /* harmless if 0 == timecnt */
 350         type = (0 < timecnt) ? (uint8_t)*typep++ : 0;
 351         if (typecnt <= type) {
 352             result = false;
 353             break;
 354         }
 355         offset = __CFDetzcode(ttisp + 6 * type);
 356         dst = (uint8_t)*(ttisp + 6 * type + 4);
 357         if (0 != dst && 1 != dst) {
 358             result = false;
 359             break;
 360         }
 361         abbridx = (uint8_t)*(ttisp + 6 * type + 5);
 362         if (charcnt < abbridx) {
 363             result = false;
 364             break;
 365         }
 366         if (NULL == abbrs[abbridx]) {
 367             abbrs[abbridx] = CFStringCreateWithCString(allocator, (char *)&charp[abbridx], kCFStringEncodingASCII);
 368         }
 369         __CFTZPeriodInit(*tzpp + idx, itime, abbrs[abbridx], offset, (dst ? true : false));
 370     }
 371     for (idx = 0; idx < charcnt + 1; idx++) {
 372         if (NULL != abbrs[idx]) {
 373             CFRelease(abbrs[idx]);
 374         }
 375     }
 376     CFAllocatorDeallocate(allocator, abbrs);
 377     if (result) {
 378         // dump all but the last INT_MIN and the first INT_MAX
 379         for (idx = 0; idx < cnt; idx++) {
 380             if (((*tzpp + idx)->startSec == INT_MIN) && (idx + 1 < cnt) && (((*tzpp + idx + 1)->startSec == INT_MIN))) {
 381                 if (NULL != (*tzpp + idx)->abbrev) CFRelease((*tzpp + idx)->abbrev);
 382                 cnt--;
 383                 memmove((*tzpp + idx), (*tzpp + idx + 1), sizeof(CFTZPeriod) * (cnt - idx));
 384                 idx--;
 385             }
 386         }
 387         // Don't combine these loops!  Watch the idx decrementing...
 388         for (idx = 0; idx < cnt; idx++) {
 389             if (((*tzpp + idx)->startSec == INT_MAX) && (0 < idx) && (((*tzpp + idx - 1)->startSec == INT_MAX))) {
 390                 if (NULL != (*tzpp + idx)->abbrev) CFRelease((*tzpp + idx)->abbrev);
 391                 cnt--;
 392                 memmove((*tzpp + idx), (*tzpp + idx + 1), sizeof(CFTZPeriod) * (cnt - idx));
 393                 idx--;
 394             }
 395         }
 396         CFQSortArray(*tzpp, cnt, sizeof(CFTZPeriod), __CFCompareTZPeriods, NULL);
 397         // if the first period is in DST and there is more than one period, drop it
 398         if (1 < cnt && __CFTZPeriodIsDST(*tzpp + 0)) {
 399             if (NULL != (*tzpp + 0)->abbrev) CFRelease((*tzpp + 0)->abbrev);
 400             cnt--;
 401             memmove((*tzpp + 0), (*tzpp + 0 + 1), sizeof(CFTZPeriod) * (cnt - 0));
 402         }
 403         *cntp = cnt;
 404     } else {
 405         CFAllocatorDeallocate(allocator, *tzpp);
 406         *tzpp = NULL;
 407     }
 408     return result;
 409 }
 410 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
 411 static Boolean __CFParseTimeZoneData(CFAllocatorRef allocator, CFDataRef data, CFTZPeriod **tzpp, CFIndex *cntp) {
 412 /* We use Win32 function to find TimeZone
 413  * (Aleksey Dukhnyakov)
 414  */
 415     *tzpp = (CFTZPeriod *)CFAllocatorAllocate(allocator, sizeof(CFTZPeriod), 0);
 416     memset(*tzpp, 0, sizeof(CFTZPeriod));
 417     __CFTZPeriodInit(*tzpp, 0, NULL, 0, false);
 418     *cntp = 1;
 419     return TRUE;
 420 }
 421 #else
 422 #error Unknown or unspecified DEPLOYMENT_TARGET
 423 #endif
 424
 425 static Boolean __CFTimeZoneEqual(CFTypeRef cf1, CFTypeRef cf2) {
 426     CFTimeZoneRef tz1 = (CFTimeZoneRef)cf1;
 427     CFTimeZoneRef tz2 = (CFTimeZoneRef)cf2;
 428     if (!CFEqual(CFTimeZoneGetName(tz1), CFTimeZoneGetName(tz2))) return false;
 429     if (!CFEqual(CFTimeZoneGetData(tz1), CFTimeZoneGetData(tz2))) return false;
 430     return true;
 431 }
 432
 433 static CFHashCode __CFTimeZoneHash(CFTypeRef cf) {
 434     CFTimeZoneRef tz = (CFTimeZoneRef)cf;
 435     return CFHash(CFTimeZoneGetName(tz));
 436 }
 437
 438 static CFStringRef __CFTimeZoneCopyDescription(CFTypeRef cf) {
 439     CFTimeZoneRef tz = (CFTimeZoneRef)cf;
 440     CFStringRef result, abbrev;
 441     CFAbsoluteTime at;
 442     at = CFAbsoluteTimeGetCurrent();
 443     abbrev = CFTimeZoneCopyAbbreviation(tz, at);
 444     result = CFStringCreateWithFormat(kCFAllocatorSystemDefault, NULL, CFSTR("<CFTimeZone %p [%p]>{name = %@; abbreviation = %@; GMT offset = %g; is DST = %s}"), cf, CFGetAllocator(tz), tz->_name, abbrev, CFTimeZoneGetSecondsFromGMT(tz, at), CFTimeZoneIsDaylightSavingTime(tz, at) ? "true" : "false");
 445     CFRelease(abbrev);
 446     return result;
 447 }
 448
 449 static void __CFTimeZoneDeallocate(CFTypeRef cf) {
 450     CFTimeZoneRef tz = (CFTimeZoneRef)cf;
 451     CFAllocatorRef allocator = CFGetAllocator(tz);
 452     CFIndex idx;
 453     if (tz->_name) CFRelease(tz->_name);
 454     if (tz->_data) CFRelease(tz->_data);
 455     for (idx = 0; idx < tz->_periodCnt; idx++) {
 456         if (NULL != tz->_periods[idx].abbrev) CFRelease(tz->_periods[idx].abbrev);
 457     }
 458     if (NULL != tz->_periods) CFAllocatorDeallocate(allocator, tz->_periods);
 459 }
 460
 461 static CFTypeID __kCFTimeZoneTypeID = _kCFRuntimeNotATypeID;
 462
 463 static const CFRuntimeClass __CFTimeZoneClass = {
 464     0,
 465     "CFTimeZone",
 466     NULL,       // init
 467     NULL,       // copy
 468     __CFTimeZoneDeallocate,
 469     __CFTimeZoneEqual,
 470     __CFTimeZoneHash,
 471     NULL,       //
 472     __CFTimeZoneCopyDescription
 473 };
 474
 475 __private_extern__ void __CFTimeZoneInitialize(void) {
 476     __kCFTimeZoneTypeID = _CFRuntimeRegisterClass(&__CFTimeZoneClass);
 477 }
 478
 479 CFTypeID CFTimeZoneGetTypeID(void) {
 480     return __kCFTimeZoneTypeID;
 481 }
 482
 483
 484 #if DEPLOYMENT_TARGET_WINDOWS_SYNC
 485 static const char *__CFTimeZoneWinToOlsonDefaults =
 486 /* Mappings to time zones in Windows Registry are best-guess */
 487 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 488 " <!DOCTYPE plist SYSTEM \"file://localhost/System/Library/DTDs/PropertyList.dtd\">"
 489 " <plist version=\"1.0\">"
 490 " <dict>"
 491 "    <key>Afghanistan</key>                 <string>Asia/Kabul</string>"
 492 "    <key>Afghanistan Standard Time</key>   <string>Asia/Kabul</string>"
 493 "    <key>Alaskan</key>                     <string>America/Anchorage</string>"
 494 "    <key>Alaskan Standard Time</key>       <string>America/Anchorage</string>"
 495 "    <key>Arab</key>                        <string>Asia/Riyadh</string>"
 496 "    <key>Arab Standard Time</key>          <string>Asia/Riyadh</string>"
 497 "    <key>Arabian</key>                     <string>Asia/Muscat</string>"
 498 "    <key>Arabian Standard Time</key>       <string>Asia/Muscat</string>"
 499 "    <key>Arabic Standard Time</key>        <string>Asia/Baghdad</string>"
 500 "    <key>Atlantic</key>                    <string>America/Halifax</string>"
 501 "    <key>Atlantic Standard Time</key>      <string>America/Halifax</string>"
 502 "    <key>AUS Central</key>                 <string>Australia/Darwin</string>"
 503 "    <key>AUS Central Standard Time</key>       <string>Australia/Darwin</string>"
 504 "    <key>AUS Eastern</key>                 <string>Australia/Sydney</string>"
 505 "    <key>AUS Eastern Standard Time</key>       <string>Australia/Sydney</string>"
 506 "    <key>Azerbaijan Standard Time</key>        <string>Asia/Baku</string>"
 507 "    <key>Azores</key>                      <string>Atlantic/Azores</string>"
 508 "    <key>Azores Standard Time</key>        <string>Atlantic/Azores</string>"
 509 "    <key>Bangkok</key>                     <string>Asia/Bangkok</string>"
 510 "    <key>Bangkok Standard Time</key>       <string>Asia/Bangkok</string>"
 511 "    <key>Beijing</key>                     <string>Asia/Shanghai</string>"
 512 "    <key>Canada Central</key>              <string>America/Regina</string>"
 513 "    <key>Canada Central Standard Time</key> <string>America/Regina</string>"
 514 "    <key>Cape Verde Standard Time</key>    <string>Atlantic/Cape_Verde</string>"
 515 "    <key>Caucasus</key>                    <string>Asia/Yerevan</string>"
 516 "    <key>Caucasus Standard Time</key>      <string>Asia/Yerevan</string>"
 517 "    <key>Cen. Australia</key>              <string>Australia/Adelaide</string>"
 518 "    <key>Cen. Australia Standard Time</key> <string>Australia/Adelaide</string>"
 519 "    <key>Central</key>                     <string>America/Chicago</string>"
 520 "    <key>Central America Standard Time</key> <string>America/Regina</string>"
 521 "    <key>Central Asia</key>                <string>Asia/Dhaka</string>"
 522 "    <key>Central Asia Standard Time</key>      <string>Asia/Dhaka</string>"
 523 "    <key>Central Brazilian Standard Time</key> <string>America/Manaus</string>"
 524 "    <key>Central Europe</key>              <string>Europe/Prague</string>"
 525 "    <key>Central Europe Standard Time</key> <string>Europe/Prague</string>"
 526 "    <key>Central European</key>            <string>Europe/Belgrade</string>"
 527 "    <key>Central European Standard Time</key>  <string>Europe/Belgrade</string>"
 528 "    <key>Central Pacific</key>             <string>Pacific/Guadalcanal</string>"
 529 "    <key>Central Pacific Standard Time</key>   <string>Pacific/Guadalcanal</string>"
 530 "    <key>Central Standard Time</key>       <string>America/Chicago</string>"
 531 "    <key>Central Standard Time (Mexico)</key> <string>America/Mexico_City</string>"
 532 "    <key>China</key>                       <string>Asia/Shanghai</string>"
 533 "    <key>China Standard Time</key>         <string>Asia/Shanghai</string>"
 534 "    <key>Dateline</key>                    <string>GMT-1200</string>"
 535 "    <key>Dateline Standard Time</key>      <string>GMT-1200</string>"
 536 "    <key>E. Africa</key>                   <string>Africa/Nairobi</string>"
 537 "    <key>E. Africa Standard Time</key>     <string>Africa/Nairobi</string>"
 538 "    <key>E. Australia</key>                <string>Australia/Brisbane</string>"
 539 "    <key>E. Australia Standard Time</key>      <string>Australia/Brisbane</string>"
 540 "    <key>E. Europe</key>                   <string>Europe/Minsk</string>"
 541 "    <key>E. Europe Standard Time</key>     <string>Europe/Minsk</string>"
 542 "    <key>E. South America</key>            <string>America/Sao_Paulo</string>"
 543 "    <key>E. South America Standard Time</key>  <string>America/Sao_Paulo</string>"
 544 "    <key>Eastern</key>                     <string>America/New_York</string>"
 545 "    <key>Eastern Standard Time</key>       <string>America/New_York</string>"
 546 "    <key>Egypt</key>       <string>Africa/Cairo</string>"
 547 "    <key>Egypt Standard Time</key> <string>Africa/Cairo</string>"
 548 "    <key>Ekaterinburg</key>                <string>Asia/Yekaterinburg</string>"
 549 "    <key>Ekaterinburg Standard Time</key>      <string>Asia/Yekaterinburg</string>"
 550 "    <key>Fiji</key>    <string>Pacific/Fiji</string>"
 551 "    <key>Fiji Standard Time</key>      <string>Pacific/Fiji</string>"
 552 "    <key>FLE</key>     <string>Europe/Helsinki</string>"
 553 "    <key>FLE Standard Time</key>       <string>Europe/Helsinki</string>"
 554 "    <key>Georgian Standard Time</key>  <string>Asia/Tbilisi</string>"
 555 "    <key>GFT</key>     <string>Europe/Athens</string>"
 556 "    <key>GFT Standard Time</key>       <string>Europe/Athens</string>"
 557 "    <key>GMT</key>     <string>Europe/London</string>"
 558 "    <key>GMT Standard Time</key>       <string>Europe/London</string>"
 559 "    <key>Greenland Standard Time</key> <string>America/Godthab</string>"
 560 "    <key>Greenwich</key>       <string>GMT</string>"
 561 "    <key>Greenwich Standard Time</key> <string>GMT</string>"
 562 "    <key>GTB</key>     <string>Europe/Athens</string>"
 563 "    <key>GTB Standard Time</key>       <string>Europe/Athens</string>"
 564 "    <key>Hawaiian</key>        <string>Pacific/Honolulu</string>"
 565 "    <key>Hawaiian Standard Time</key>  <string>Pacific/Honolulu</string>"
 566 "    <key>India</key>   <string>Asia/Calcutta</string>"
 567 "    <key>India Standard Time</key>     <string>Asia/Calcutta</string>"
 568 "    <key>Iran</key>    <string>Asia/Tehran</string>"
 569 "    <key>Iran Standard Time</key>      <string>Asia/Tehran</string>"
 570 "    <key>Israel</key>  <string>Asia/Jerusalem</string>"
 571 "    <key>Israel Standard Time</key>    <string>Asia/Jerusalem</string>"
 572 "    <key>Jordan Standard Time</key>    <string>Asia/Amman</string>"
 573 "    <key>Korea</key>   <string>Asia/Seoul</string>"
 574 "    <key>Korea Standard Time</key>     <string>Asia/Seoul</string>"
 575 "    <key>Mexico</key>  <string>America/Mexico_City</string>"
 576 "    <key>Mexico Standard Time</key>    <string>America/Mexico_City</string>"
 577 "    <key>Mexico Standard Time 2</key>  <string>America/Chihuahua</string>"
 578 "    <key>Mid-Atlantic</key>    <string>Atlantic/South_Georgia</string>"
 579 "    <key>Mid-Atlantic Standard Time</key>      <string>Atlantic/South_Georgia</string>"
 580 "    <key>Middle East Standard Time</key>       <string>Asia/Beirut</string>"
 581 "    <key>Mountain</key>        <string>America/Denver</string>"
 582 "    <key>Mountain Standard Time</key>  <string>America/Denver</string>"
 583 "    <key>Mountain Standard Time (Mexico)</key> <string>America/Chihuahua</string>"
 584 "    <key>Myanmar Standard Time</key>   <string>Asia/Rangoon</string>"
 585 "    <key>N. Central Asia Standard Time</key>   <string>Asia/Novosibirsk</string>"
 586 "    <key>Namibia Standard Time</key>   <string>Africa/Windhoek</string>"
 587 "    <key>Nepal Standard Time</key>     <string>Asia/Katmandu</string>"
 588 "    <key>New Zealand</key>     <string>Pacific/Auckland</string>"
 589 "    <key>New Zealand Standard Time</key>       <string>Pacific/Auckland</string>"
 590 "    <key>Newfoundland</key>    <string>America/St_Johns</string>"
 591 "    <key>Newfoundland Standard Time</key>      <string>America/St_Johns</string>"
 592 "    <key>North Asia East Standard Time</key>   <string>Asia/Ulaanbaatar</string>"
 593 "    <key>North Asia Standard Time</key>        <string>Asia/Krasnoyarsk</string>"
 594 "    <key>Pacific</key> <string>America/Los_Angeles</string>"
 595 "    <key>Pacific SA</key>      <string>America/Santiago</string>"
 596 "    <key>Pacific SA Standard Time</key>        <string>America/Santiago</string>"
 597 "    <key>Pacific Standard Time</key>   <string>America/Los_Angeles</string>"
 598 "    <key>Pacific Standard Time (Mexico)</key>  <string>America/Tijuana</string>"
 599 "    <key>Prague Bratislava</key>       <string>Europe/Prague</string>"
 600 "    <key>Romance</key> <string>Europe/Paris</string>"
 601 "    <key>Romance Standard Time</key>   <string>Europe/Paris</string>"
 602 "    <key>Russian</key> <string>Europe/Moscow</string>"
 603 "    <key>Russian Standard Time</key>   <string>Europe/Moscow</string>"
 604 "    <key>SA Eastern</key>      <string>America/Buenos_Aires</string>"
 605 "    <key>SA Eastern Standard Time</key>        <string>America/Buenos_Aires</string>"
 606 "    <key>SA Pacific</key>      <string>America/Bogota</string>"
 607 "    <key>SA Pacific Standard Time</key>        <string>America/Bogota</string>"
 608 "    <key>SA Western</key>      <string>America/Caracas</string>"
 609 "    <key>SA Western Standard Time</key>        <string>America/Caracas</string>"
 610 "    <key>Samoa</key>   <string>Pacific/Apia</string>"
 611 "    <key>Samoa Standard Time</key>     <string>Pacific/Apia</string>"
 612 "    <key>Saudi Arabia</key>    <string>Asia/Riyadh</string>"
 613 "    <key>Saudi Arabia Standard Time</key>      <string>Asia/Riyadh</string>"
 614 "    <key>SE Asia Standard Time</key>   <string>Asia/Bangkok</string>"
 615 "    <key>Singapore</key>       <string>Asia/Singapore</string>"
 616 "    <key>Singapore Standard Time</key> <string>Asia/Singapore</string>"
 617 "    <key>South Africa</key>    <string>Africa/Harare</string>"
 618 "    <key>South Africa Standard Time</key>      <string>Africa/Harare</string>"
 619 "    <key>Sri Lanka</key>       <string>Asia/Colombo</string>"
 620 "    <key>Sri Lanka Standard Time</key> <string>Asia/Colombo</string>"
 621 "    <key>Sydney Standard Time</key>    <string>Australia/Sydney</string>"
 622 "    <key>Taipei</key>  <string>Asia/Taipei</string>"
 623 "    <key>Taipei Standard Time</key>    <string>Asia/Taipei</string>"
 624 "    <key>Tasmania</key>        <string>Australia/Hobart</string>"
 625 "    <key>Tasmania Standard Time</key>  <string>Australia/Hobart</string>"
 626 "    <key>Tasmania Standard Time</key>  <string>Australia/Hobart</string>"
 627 "    <key>Tokyo</key>   <string>Asia/Tokyo</string>"
 628 "    <key>Tokyo Standard Time</key>     <string>Asia/Tokyo</string>"
 629 "    <key>Tonga Standard Time</key>     <string>Pacific/Tongatapu</string>"
 630 "    <key>US Eastern</key>      <string>America/Indianapolis</string>"
 631 "    <key>US Eastern Standard Time</key>        <string>America/Indianapolis</string>"
 632 "    <key>US Mountain</key>     <string>America/Phoenix</string>"
 633 "    <key>US Mountain Standard Time</key>       <string>America/Phoenix</string>"
 634 "    <key>Vladivostok</key>     <string>Asia/Vladivostok</string>"
 635 "    <key>Vladivostok Standard Time</key>       <string>Asia/Vladivostok</string>"
 636 "    <key>W. Australia</key>    <string>Australia/Perth</string>"
 637 "    <key>W. Australia Standard Time</key>      <string>Australia/Perth</string>"
 638 "    <key>W. Central Africa Standard Time</key> <string>Africa/Luanda</string>"
 639 "    <key>W. Europe</key>       <string>Europe/Berlin</string>"
 640 "    <key>W. Europe Standard Time</key> <string>Europe/Berlin</string>"
 641 "    <key>Warsaw</key>  <string>Europe/Warsaw</string>"
 642 "    <key>West Asia</key>       <string>Asia/Karachi</string>"
 643 "    <key>West Asia Standard Time</key> <string>Asia/Karachi</string>"
 644 "    <key>West Pacific</key>    <string>Pacific/Guam</string>"
 645 "    <key>West Pacific Standard Time</key>      <string>Pacific/Guam</string>"
 646 "    <key>Western Brazilian Standard Time</key> <string>America/Rio_Branco</string>"
 647 "    <key>Yakutsk</key> <string>Asia/Yakutsk</string>"
 648 " </dict>"
 649 " </plist>";
 650
 651 CF_INLINE void __CFTimeZoneLockWinToOlson(void) {
 652     __CFSpinLock(&__CFTimeZoneWinToOlsonLock);
 653 }
 654
 655 CF_INLINE void __CFTimeZoneUnlockWinToOlson(void) {
 656     __CFSpinUnlock(&__CFTimeZoneWinToOlsonLock);
 657 }
 658
 659 CFDictionaryRef CFTimeZoneCopyWinToOlsonDictionary(void) {
 660     CFDictionaryRef dict;
 661     __CFTimeZoneLockWinToOlson();
 662     if (NULL == __CFTimeZoneWinToOlsonDict) {
 663         CFDataRef data = CFDataCreate(kCFAllocatorSystemDefault, (uint8_t *)__CFTimeZoneWinToOlsonDefaults, strlen(__CFTimeZoneWinToOlsonDefaults));
 664         __CFTimeZoneWinToOlsonDict = (CFDictionaryRef)CFPropertyListCreateFromXMLData(kCFAllocatorSystemDefault, data, kCFPropertyListImmutable, NULL);
 665         CFRelease(data);
 666     }
 667     if (NULL == __CFTimeZoneWinToOlsonDict) {
 668         __CFTimeZoneWinToOlsonDict = CFDictionaryCreate(kCFAllocatorSystemDefault, NULL, NULL, 0, NULL, NULL);
 669     }
 670     dict = __CFTimeZoneWinToOlsonDict ? (CFDictionaryRef)CFRetain(__CFTimeZoneWinToOlsonDict) : NULL;
 671     __CFTimeZoneUnlockWinToOlson();
 672     return dict;
 673 }
 674
 675 void CFTimeZoneSetWinToOlsonDictionary(CFDictionaryRef dict) {
 676     __CFGenericValidateType(dict, CFDictionaryGetTypeID());
 677     __CFTimeZoneLockWinToOlson();
 678     if (dict != __CFTimeZoneWinToOlsonDict) {
 679         if (dict) CFRetain(dict);
 680         if (__CFTimeZoneWinToOlsonDict) CFRelease(__CFTimeZoneWinToOlsonDict);
 681         __CFTimeZoneWinToOlsonDict = dict;
 682     }
 683     __CFTimeZoneUnlockWinToOlson();
 684 }
 685
 686 CFTimeZoneRef CFTimeZoneCreateWithWindowsName(CFAllocatorRef allocator, CFStringRef winName) {
 687     if (!winName) return NULL;
 688
 689     CFDictionaryRef winToOlson = CFTimeZoneCopyWinToOlsonDictionary();
 690     if (!winToOlson) return NULL;
 691
 692     CFStringRef olsonName = CFDictionaryGetValue(winToOlson, winName);
 693     CFTimeZoneRef retval = NULL;
 694     if (olsonName) {
 695          retval = CFTimeZoneCreateWithName(allocator, olsonName, false);
 696     }
 697     CFRelease(winToOlson);
 698     return retval;
 699 }
 700
 701 extern CFStringRef _CFGetWindowsAppleSystemLibraryDirectory(void);
 702 void __InitTZStrings(void) {
 703     static CFSpinLock_t __CFTZDirLock = CFSpinLockInit;
 704     __CFSpinLock(&__CFTZDirLock);
 705     if (!__tzZoneInfo) {
 706         CFStringRef winDir = _CFGetWindowsAppleSystemLibraryDirectory();
 707         __tzZoneInfo = CFStringCreateWithFormat(NULL, NULL, CFSTR("%@\\etc\\zoneinfo"), winDir);
 708     }
 709     if (!__tzDir && __tzZoneInfo) {
 710         int length = CFStringGetLength(__tzZoneInfo) + sizeof("\\zone.tab") + 1;
 711         __tzDir = malloc(length); // If we don't use ascii, we'll need to malloc more space
 712         if (!__tzDir || !CFStringGetCString(__tzZoneInfo, __tzDir, length, kCFStringEncodingASCII)) {
 713             free(__tzDir);
 714         } else {
 715             strcat(__tzDir, "\\zone.tab");
 716         }
 717     }
 718     __CFSpinUnlock(&__CFTZDirLock);
 719 }
 720 #endif
 721
 722 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
 723 static CFTimeZoneRef __CFTimeZoneCreateSystem(void) {
 724     CFTimeZoneRef result = NULL;
 725
 726 #if DEPLOYMENT_TARGET_WINDOWS_SYNC
 727     CFStringRef name = NULL;
 728     TIME_ZONE_INFORMATION tzi = { 0 };
 729     DWORD rval = GetTimeZoneInformation(&tzi);
 730     if (rval != TIME_ZONE_ID_INVALID) {
 731         LPWSTR standardName = (LPWSTR)&tzi.StandardName;
 732         CFStringRef cfStandardName = CFStringCreateWithBytes(kCFAllocatorSystemDefault, (UInt8 *)standardName, wcslen(standardName)*sizeof(WCHAR), kCFStringEncodingUTF16LE, false);
 733         if (cfStandardName) {
 734             CFDictionaryRef winToOlson = CFTimeZoneCopyWinToOlsonDictionary();
 735             if (winToOlson) {
 736                 name = CFDictionaryGetValue(winToOlson, cfStandardName);
 737                 if (name) CFRetain(name);
 738                 CFRelease(winToOlson);
 739             }
 740             CFRelease(cfStandardName);
 741         }
 742     } else {
 743         CFLog(kCFLogLevelError, CFSTR("Couldn't get time zone information error %d"), GetLastError());
 744     }
 745     if (name) {
 746 #else
 747     const char *tzenv;
 748     int ret;
 749     char linkbuf[CFMaxPathSize];
 750
 751     tzenv = __CFgetenv("TZFILE");
 752     if (NULL != tzenv) {
 753         CFStringRef name = CFStringCreateWithBytes(kCFAllocatorSystemDefault, (uint8_t *)tzenv, strlen(tzenv), kCFStringEncodingUTF8, false);
 754         result = CFTimeZoneCreateWithName(kCFAllocatorSystemDefault, name, false);
 755         CFRelease(name);
 756         if (result) return result;
 757     }
 758     tzenv = __CFgetenv("TZ");
 759     if (NULL != tzenv) {
 760         CFStringRef name = CFStringCreateWithBytes(kCFAllocatorSystemDefault, (uint8_t *)tzenv, strlen(tzenv), kCFStringEncodingUTF8, false);
 761         result = CFTimeZoneCreateWithName(kCFAllocatorSystemDefault, name, true);
 762         CFRelease(name);
 763         if (result) return result;
 764     }
 765     ret = readlink(TZZONELINK, linkbuf, sizeof(linkbuf));
 766     if (0 < ret) {
 767         CFStringRef name;
 768         linkbuf[ret] = '\0';
 769         if (strncmp(linkbuf, TZZONEINFO, sizeof(TZZONEINFO) - 1) == 0) {
 770             name = CFStringCreateWithBytes(kCFAllocatorSystemDefault, (uint8_t *)linkbuf + sizeof(TZZONEINFO) - 1, strlen(linkbuf) - sizeof(TZZONEINFO) + 1, kCFStringEncodingUTF8, false);
 771         } else {
 772             name = CFStringCreateWithBytes(kCFAllocatorSystemDefault, (uint8_t *)linkbuf, strlen(linkbuf), kCFStringEncodingUTF8, false);
 773         }
 774 #endif
 775
 776         result = CFTimeZoneCreateWithName(kCFAllocatorSystemDefault, name, false);
 777         CFRelease(name);
 778         if (result) return result;
 779     }
 780     return CFTimeZoneCreateWithTimeIntervalFromGMT(kCFAllocatorSystemDefault, 0.0);
 781 }
 782 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
 783 static CFTimeZoneRef __CFTimeZoneCreateSystem(void) {
 784     CFTimeZoneRef result = NULL;
 785 /* The GetTimeZoneInformation function retrieves the current
 786  * time-zone parameters for Win32
 787  * (Aleksey Dukhnyakov)
 788  */
 789     CFDataRef data;
 790     TIME_ZONE_INFORMATION tz;
 791     DWORD dw_result;
 792     dw_result=GetTimeZoneInformation(&tz);
 793
 794     if ( dw_result == TIME_ZONE_ID_STANDARD ||
 795             dw_result == TIME_ZONE_ID_DAYLIGHT ) {
 796         CFStringRef name = CFStringCreateWithCharacters(kCFAllocatorSystemDefault, (const UniChar *)tz.StandardName, wcslen(tz.StandardName));
 797         data = CFDataCreate(kCFAllocatorSystemDefault, (UInt8 *)&tz, sizeof(tz));
 798         result = CFTimeZoneCreate(kCFAllocatorSystemDefault, name, data);
 799         CFRelease(name);
 800         CFRelease(data);
 801         if (result) return result;
 802     }
 803     return CFTimeZoneCreateWithTimeIntervalFromGMT(kCFAllocatorSystemDefault, 0.0);
 804 }
 805 #else
 806 #error Unknown or unspecified DEPLOYMENT_TARGET
 807 #endif
 808
 809 CFTimeZoneRef CFTimeZoneCopySystem(void) {
 810     CFTimeZoneRef tz;
 811     __CFTimeZoneLockGlobal();
 812     if (NULL == __CFTimeZoneSystem) {
 813         __CFTimeZoneUnlockGlobal();
 814         tz = __CFTimeZoneCreateSystem();
 815         __CFTimeZoneLockGlobal();
 816         if (NULL == __CFTimeZoneSystem) {
 817             __CFTimeZoneSystem = tz;
 818         } else {
 819             if (tz) CFRelease(tz);
 820         }
 821     }
 822     tz = __CFTimeZoneSystem ? (CFTimeZoneRef)CFRetain(__CFTimeZoneSystem) : NULL;
 823     __CFTimeZoneUnlockGlobal();
 824     return tz;
 825 }
 826
 827 static CFIndex __noteCount = 0;
 828
 829 void CFTimeZoneResetSystem(void) {
 830     __CFTimeZoneLockGlobal();
 831     if (__CFTimeZoneDefault == __CFTimeZoneSystem) {
 832         if (__CFTimeZoneDefault) CFRelease(__CFTimeZoneDefault);
 833         __CFTimeZoneDefault = NULL;
 834     }
 835     CFTimeZoneRef tz = __CFTimeZoneSystem;
 836     __CFTimeZoneSystem = NULL;
 837     __CFTimeZoneUnlockGlobal();
 838     if (tz) CFRelease(tz);
 839 }
 840
 841 CFIndex _CFTimeZoneGetNoteCount(void) {
 842     return __noteCount;
 843 }
 844
 845 CFTimeZoneRef CFTimeZoneCopyDefault(void) {
 846     CFTimeZoneRef tz;
 847     __CFTimeZoneLockGlobal();
 848     if (NULL == __CFTimeZoneDefault) {
 849         __CFTimeZoneUnlockGlobal();
 850         tz = CFTimeZoneCopySystem();
 851         __CFTimeZoneLockGlobal();
 852         if (NULL == __CFTimeZoneDefault) {
 853             __CFTimeZoneDefault = tz;
 854         } else {
 855             if (tz) CFRelease(tz);
 856         }
 857     }
 858     tz = __CFTimeZoneDefault ? (CFTimeZoneRef)CFRetain(__CFTimeZoneDefault) : NULL;
 859     __CFTimeZoneUnlockGlobal();
 860     return tz;
 861 }
 862
 863 void CFTimeZoneSetDefault(CFTimeZoneRef tz) {
 864     if (tz) __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
 865     __CFTimeZoneLockGlobal();
 866     if (tz != __CFTimeZoneDefault) {
 867         if (tz) CFRetain(tz);
 868         if (__CFTimeZoneDefault) CFRelease(__CFTimeZoneDefault);
 869         __CFTimeZoneDefault = tz;
 870     }
 871     __CFTimeZoneUnlockGlobal();
 872 }
 873
 874 static CFDictionaryRef __CFTimeZoneCopyCompatibilityDictionary(void);
 875
 876 CFArrayRef CFTimeZoneCopyKnownNames(void) {
 877     CFArrayRef tzs;
 878     __CFTimeZoneLockGlobal();
 879     if (NULL == __CFKnownTimeZoneList) {
 880         CFMutableArrayRef list;
 881 /* TimeZone information locate in the registry for Win32
 882  * (Aleksey Dukhnyakov)
 883  */
 884 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
 885         list = __CFCopyRecursiveDirectoryList();
 886 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
 887         list = __CFCopyWindowsTimeZoneList();
 888 #else
 889 #error Unknown or unspecified DEPLOYMENT_TARGET
 890 #endif
 891         // Remove undesirable ancient cruft
 892         CFDictionaryRef dict = __CFTimeZoneCopyCompatibilityDictionary();
 893         CFIndex idx;
 894         for (idx = CFArrayGetCount(list); idx--; ) {
 895             CFStringRef item = (CFStringRef)CFArrayGetValueAtIndex(list, idx);
 896             if (CFDictionaryContainsKey(dict, item)) {
 897                 CFArrayRemoveValueAtIndex(list, idx);
 898             }
 899         }
 900         __CFKnownTimeZoneList = CFArrayCreateCopy(kCFAllocatorSystemDefault, list);
 901         CFRelease(list);
 902     }
 903     tzs = __CFKnownTimeZoneList ? (CFArrayRef)CFRetain(__CFKnownTimeZoneList) : NULL;
 904     __CFTimeZoneUnlockGlobal();
 905     return tzs;
 906 }
 907
 908 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
 909 /* The criteria here are sort of: coverage for the U.S. and Europe,
 910  * large cities, abbreviation uniqueness, and perhaps a few others.
 911  * But do not make the list too large with obscure information.
 912  */
 913 static const char *__CFTimeZoneAbbreviationDefaults =
 914 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 915 " <!DOCTYPE plist SYSTEM \"file://localhost/System/Library/DTDs/PropertyList.dtd\">"
 916 " <plist version=\"1.0\">"
 917 " <dict>"
 918 "    <key>ADT</key>  <string>America/Halifax</string>"
 919 "    <key>AKDT</key> <string>America/Juneau</string>"
 920 "    <key>AKST</key> <string>America/Juneau</string>"
 921 "    <key>ART</key>  <string>America/Argentina/Buenos_Aires</string>"
 922 "    <key>AST</key>  <string>America/Halifax</string>"
 923 "    <key>BDT</key>  <string>Asia/Dhaka</string>"
 924 "    <key>BRST</key> <string>America/Sao_Paulo</string>"
 925 "    <key>BRT</key>  <string>America/Sao_Paulo</string>"
 926 "    <key>BST</key>  <string>Europe/London</string>"
 927 "    <key>CAT</key>  <string>Africa/Harare</string>"
 928 "    <key>CDT</key>  <string>America/Chicago</string>"
 929 "    <key>CEST</key> <string>Europe/Paris</string>"
 930 "    <key>CET</key>  <string>Europe/Paris</string>"
 931 "    <key>CLST</key> <string>America/Santiago</string>"
 932 "    <key>CLT</key>  <string>America/Santiago</string>"
 933 "    <key>COT</key>  <string>America/Bogota</string>"
 934 "    <key>CST</key>  <string>America/Chicago</string>"
 935 "    <key>EAT</key>  <string>Africa/Addis_Ababa</string>"
 936 "    <key>EDT</key>  <string>America/New_York</string>"
 937 "    <key>EEST</key> <string>Europe/Istanbul</string>"
 938 "    <key>EET</key>  <string>Europe/Istanbul</string>"
 939 "    <key>EST</key>  <string>America/New_York</string>"
 940 "    <key>GMT</key>  <string>GMT</string>"
 941 "    <key>GST</key>  <string>Asia/Dubai</string>"
 942 "    <key>HKT</key>  <string>Asia/Hong_Kong</string>"
 943 "    <key>HST</key>  <string>Pacific/Honolulu</string>"
 944 "    <key>ICT</key>  <string>Asia/Bangkok</string>"
 945 "    <key>IRST</key> <string>Asia/Tehran</string>"
 946 "    <key>IST</key>  <string>Asia/Calcutta</string>"
 947 "    <key>JST</key>  <string>Asia/Tokyo</string>"
 948 "    <key>KST</key>  <string>Asia/Seoul</string>"
 949 "    <key>MDT</key>  <string>America/Denver</string>"
 950 "    <key>MSD</key>  <string>Europe/Moscow</string>"
 951 "    <key>MSK</key>  <string>Europe/Moscow</string>"
 952 "    <key>MST</key>  <string>America/Denver</string>"
 953 "    <key>NZDT</key> <string>Pacific/Auckland</string>"
 954 "    <key>NZST</key> <string>Pacific/Auckland</string>"
 955 "    <key>PDT</key>  <string>America/Los_Angeles</string>"
 956 "    <key>PET</key>  <string>America/Lima</string>"
 957 "    <key>PHT</key>  <string>Asia/Manila</string>"
 958 "    <key>PKT</key>  <string>Asia/Karachi</string>"
 959 "    <key>PST</key>  <string>America/Los_Angeles</string>"
 960 "    <key>SGT</key>  <string>Asia/Singapore</string>"
 961 "    <key>UTC</key>  <string>UTC</string>"
 962 "    <key>WAT</key>  <string>Africa/Lagos</string>"
 963 "    <key>WEST</key> <string>Europe/Lisbon</string>"
 964 "    <key>WET</key>  <string>Europe/Lisbon</string>"
 965 "    <key>WIT</key>  <string>Asia/Jakarta</string>"
 966 " </dict>"
 967 " </plist>";
 968 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
 969 static const char *__CFTimeZoneAbbreviationDefaults =
 970 /* Mappings to time zones in Windows Registry are best-guess */
 971 "<?xml version=\"1.0\" encoding=\"UTF-8\"?>"
 972 " <!DOCTYPE plist SYSTEM \"file://localhost/System/Library/DTDs/PropertyList.dtd\">"
 973 " <plist version=\"1.0\">"
 974 " <dict>"
 975 "    <key>ADT</key>  <string>Atlantic Standard Time</string>"
 976 "    <key>AKDT</key> <string>Alaskan Standard Time</string>"
 977 "    <key>AKST</key> <string>Alaskan Standard Time</string>"
 978 "    <key>ART</key>  <string>SA Eastern Standard Time</string>"
 979 "    <key>AST</key>  <string>Atlantic Standard Time</string>"
 980 "    <key>BDT</key>  <string>Central Asia Standard Time</string>"
 981 "    <key>BRST</key> <string>SA Eastern Standard Time</string>"
 982 "    <key>BRT</key>  <string>SA Eastern Standard Time</string>"
 983 "    <key>BST</key>  <string>GMT Standard Time</string>"
 984 "    <key>CAT</key>  <string>South Africa Standard Time</string>"
 985 "    <key>CDT</key>  <string>Central Standard Time</string>"
 986 "    <key>CEST</key> <string>Central Europe Standard Time</string>"
 987 "    <key>CET</key>  <string>Central Europe Standard Time</string>"
 988 "    <key>CLST</key> <string>SA Western Standard Time</string>"
 989 "    <key>CLT</key>  <string>SA Western Standard Time</string>"
 990 "    <key>COT</key>  <string>Central Standard Time</string>"
 991 "    <key>CST</key>  <string>Central Standard Time</string>"
 992 "    <key>EAT</key>  <string>E. Africa Standard Time</string>"
 993 "    <key>EDT</key>  <string>Eastern Standard Time</string>"
 994 "    <key>EEST</key> <string>E. Europe Standard Time</string>"
 995 "    <key>EET</key>  <string>E. Europe Standard Time</string>"
 996 "    <key>EST</key>  <string>Eastern Standard Time</string>"
 997 "    <key>GMT</key>  <string>Greenwich Standard Time</string>"
 998 "    <key>GST</key>  <string>Arabian Standard Time</string>"
 999 "    <key>HKT</key>  <string>China Standard Time</string>"
1000 "    <key>HST</key>  <string>Hawaiian Standard Time</string>"
1001 "    <key>ICT</key>  <string>SE Asia Standard Time</string>"
1002 "    <key>IRST</key> <string>Iran Standard Time</string>"
1003 "    <key>IST</key>  <string>India Standard Time</string>"
1004 "    <key>JST</key>  <string>Tokyo Standard Time</string>"
1005 "    <key>KST</key>  <string>Korea Standard Time</string>"
1006 "    <key>MDT</key>  <string>Mountain Standard Time</string>"
1007 "    <key>MSD</key>  <string>E. Europe Standard Time</string>"
1008 "    <key>MSK</key>  <string>E. Europe Standard Time</string>"
1009 "    <key>MST</key>  <string>Mountain Standard Time</string>"
1010 "    <key>NZDT</key> <string>New Zealand Standard Time</string>"
1011 "    <key>NZST</key> <string>New Zealand Standard Time</string>"
1012 "    <key>PDT</key>  <string>Pacific Standard Time</string>"
1013 "    <key>PET</key>  <string>SA Pacific Standard Time</string>"
1014 "    <key>PHT</key>  <string>Taipei Standard Time</string>"
1015 "    <key>PKT</key>  <string>West Asia Standard Time</string>"
1016 "    <key>PST</key>  <string>Pacific Standard Time</string>"
1017 "    <key>SGT</key>  <string>Singapore Standard Time</string>"
1018 "    <key>UTC</key>  <string>Greenwich Standard Time</string>"
1019 "    <key>WAT</key>  <string>W. Central Africa Standard Time</string>"
1020 "    <key>WEST</key> <string>W. Europe Standard Time</string>"
1021 "    <key>WET</key>  <string>W. Europe Standard Time</string>"
1022 "    <key>WIT</key>  <string>SE Asia Standard Time</string>"
1023 " </dict>"
1024 " </plist>";
1025 #else
1026 #error Unknown or unspecified DEPLOYMENT_TARGET
1027 #endif
1028
1029 CFDictionaryRef CFTimeZoneCopyAbbreviationDictionary(void) {
1030     CFDictionaryRef dict;
1031     __CFTimeZoneLockAbbreviations();
1032     if (NULL == __CFTimeZoneAbbreviationDict) {
1033         CFDataRef data = CFDataCreate(kCFAllocatorSystemDefault, (uint8_t *)__CFTimeZoneAbbreviationDefaults, strlen(__CFTimeZoneAbbreviationDefaults));
1034         __CFTimeZoneAbbreviationDict = (CFDictionaryRef)CFPropertyListCreateFromXMLData(kCFAllocatorSystemDefault, data, kCFPropertyListImmutable, NULL);
1035         CFRelease(data);
1036     }
1037     if (NULL == __CFTimeZoneAbbreviationDict) {
1038         __CFTimeZoneAbbreviationDict = CFDictionaryCreate(kCFAllocatorSystemDefault, NULL, NULL, 0, NULL, NULL);
1039     }
1040     dict = __CFTimeZoneAbbreviationDict ? (CFDictionaryRef)CFRetain(__CFTimeZoneAbbreviationDict) : NULL;
1041     __CFTimeZoneUnlockAbbreviations();
1042     return dict;
1043 }
1044
1045 void CFTimeZoneSetAbbreviationDictionary(CFDictionaryRef dict) {
1046     __CFGenericValidateType(dict, CFDictionaryGetTypeID());
1047     __CFTimeZoneLockGlobal();
1048     if (dict != __CFTimeZoneAbbreviationDict) {
1049         if (dict) CFRetain(dict);
1050         if (__CFTimeZoneAbbreviationDict) {
1051             for (id key in (id)__CFTimeZoneAbbreviationDict) {
1052                 CFDictionaryRemoveValue(__CFTimeZoneCache, (CFStringRef)key);
1053             }
1054             CFRelease(__CFTimeZoneAbbreviationDict);
1055         }
1056         __CFTimeZoneAbbreviationDict = dict;
1057     }
1058     __CFTimeZoneUnlockGlobal();
1059 }
1060
1061 CFTimeZoneRef CFTimeZoneCreate(CFAllocatorRef allocator, CFStringRef name, CFDataRef data) {
1062 // assert:    (NULL != name && NULL != data);
1063     CFTimeZoneRef memory;
1064     uint32_t size;
1065     CFTZPeriod *tzp = NULL;
1066     CFIndex idx, cnt = 0;
1067
1068     if (allocator == NULL) allocator = __CFGetDefaultAllocator();
1069     __CFGenericValidateType(allocator, CFAllocatorGetTypeID());
1070     __CFGenericValidateType(name, CFStringGetTypeID());
1071     __CFGenericValidateType(data, CFDataGetTypeID());
1072     __CFTimeZoneLockGlobal();
1073     if (NULL != __CFTimeZoneCache && CFDictionaryGetValueIfPresent(__CFTimeZoneCache, name, (const void **)&memory)) {
1074         __CFTimeZoneUnlockGlobal();
1075         return (CFTimeZoneRef)CFRetain(memory);
1076     }
1077     if (!__CFParseTimeZoneData(allocator, data, &tzp, &cnt)) {
1078         __CFTimeZoneUnlockGlobal();
1079         return NULL;
1080     }
1081     size = sizeof(struct __CFTimeZone) - sizeof(CFRuntimeBase);
1082     memory = (CFTimeZoneRef)_CFRuntimeCreateInstance(allocator, CFTimeZoneGetTypeID(), size, NULL);
1083     if (NULL == memory) {
1084         __CFTimeZoneUnlockGlobal();
1085         for (idx = 0; idx < cnt; idx++) {
1086             if (NULL != tzp[idx].abbrev) CFRelease(tzp[idx].abbrev);
1087         }
1088         if (NULL != tzp) CFAllocatorDeallocate(allocator, tzp);
1089         return NULL;
1090     }
1091     ((struct __CFTimeZone *)memory)->_name = (CFStringRef)CFStringCreateCopy(allocator, name);
1092     ((struct __CFTimeZone *)memory)->_data = CFDataCreateCopy(allocator, data);
1093     ((struct __CFTimeZone *)memory)->_periods = tzp;
1094     ((struct __CFTimeZone *)memory)->_periodCnt = cnt;
1095     if (NULL == __CFTimeZoneCache) {
1096         __CFTimeZoneCache = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 0, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
1097     }
1098     CFDictionaryAddValue(__CFTimeZoneCache, ((struct __CFTimeZone *)memory)->_name, memory);
1099     __CFTimeZoneUnlockGlobal();
1100     return memory;
1101 }
1102
1103 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
1104 static CFTimeZoneRef __CFTimeZoneCreateFixed(CFAllocatorRef allocator, int32_t seconds, CFStringRef name, int isDST) {
1105     CFTimeZoneRef result;
1106     CFDataRef data;
1107     int32_t nameLen = CFStringGetLength(name);
1108     unsigned char dataBytes[52 + nameLen + 1];
1109     memset(dataBytes, 0, sizeof(dataBytes));
1110
1111     // Put in correct magic bytes for timezone structures
1112     dataBytes[0] = 'T';
1113     dataBytes[1] = 'Z';
1114     dataBytes[2] = 'i';
1115     dataBytes[3] = 'f';
1116
1117     __CFEntzcode(1, dataBytes + 20);
1118     __CFEntzcode(1, dataBytes + 24);
1119     __CFEntzcode(1, dataBytes + 36);
1120     __CFEntzcode(nameLen + 1, dataBytes + 40);
1121     __CFEntzcode(seconds, dataBytes + 44);
1122     dataBytes[48] = isDST ? 1 : 0;
1123     CFStringGetCString(name, (char *)dataBytes + 50, nameLen + 1, kCFStringEncodingASCII);
1124     data = CFDataCreate(allocator, dataBytes, 52 + nameLen + 1);
1125     result = CFTimeZoneCreate(allocator, name, data);
1126     CFRelease(data);
1127     return result;
1128 }
1129 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
1130 static CFTimeZoneRef __CFTimeZoneCreateFixed(CFAllocatorRef allocator, int32_t seconds, CFStringRef name, int isDST) {
1131 /* CFTimeZoneRef->_data will contain TIME_ZONE_INFORMATION structure
1132  * to find current timezone
1133  * (Aleksey Dukhnyakov)
1134  */
1135     CFTimeZoneRef result;
1136     TIME_ZONE_INFORMATION tzi;
1137     CFDataRef data;
1138     CFIndex length = CFStringGetLength(name);
1139
1140     memset(&tzi,0,sizeof(tzi));
1141     tzi.Bias=(long)(-seconds/60);
1142     CFStringGetCharacters(name, CFRangeMake(0, length < 31 ? length : 31 ), (UniChar *)tzi.StandardName);
1143     data = CFDataCreate(allocator,(UInt8 *)&tzi, sizeof(tzi));
1144     result = CFTimeZoneCreate(allocator, name, data);
1145     CFRelease(data);
1146     return result;
1147 }
1148 #else
1149 #error Unknown or unspecified DEPLOYMENT_TARGET
1150 #endif
1151
1152 // rounds offset to nearest minute
1153 CFTimeZoneRef CFTimeZoneCreateWithTimeIntervalFromGMT(CFAllocatorRef allocator, CFTimeInterval ti) {
1154     CFTimeZoneRef result;
1155     CFStringRef name;
1156     int32_t seconds, minute, hour;
1157     if (allocator == NULL) allocator = __CFGetDefaultAllocator();
1158     __CFGenericValidateType(allocator, CFAllocatorGetTypeID());
1159     if (ti < -18.0 * 3600 || 18.0 * 3600 < ti) return NULL;
1160     ti = (ti < 0.0) ? ceil((ti / 60.0) - 0.5) * 60.0 : floor((ti / 60.0) + 0.5) * 60.0;
1161     seconds = (int32_t)ti;
1162     hour = (ti < 0) ? (-seconds / 3600) : (seconds / 3600);
1163     seconds -= ((ti < 0) ? -hour : hour) * 3600;
1164     minute = (ti < 0) ? (-seconds / 60) : (seconds / 60);
1165     if (fabs(ti) < 1.0) {
1166 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
1167         name = (CFStringRef)CFRetain(CFSTR("GMT"));
1168 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
1169         name = (CFStringRef)CFRetain(CFSTR("Greenwich Standard Time"));
1170 #else
1171 #error Unknown or unspecified DEPLOYMENT_TARGET
1172 #endif
1173     } else {
1174         name = CFStringCreateWithFormat(allocator, NULL, CFSTR("GMT%c%02d%02d"), (ti < 0.0 ? '-' : '+'), hour, minute);
1175     }
1176     result = __CFTimeZoneCreateFixed(allocator, (int32_t)ti, name, 0);
1177     CFRelease(name);
1178     return result;
1179 }
1180
1181 CFTimeZoneRef CFTimeZoneCreateWithName(CFAllocatorRef allocator, CFStringRef name, Boolean tryAbbrev) {
1182     CFTimeZoneRef result = NULL;
1183     CFStringRef tzName = NULL;
1184     CFDataRef data = NULL;
1185
1186     if (allocator == NULL) allocator = __CFGetDefaultAllocator();
1187     __CFGenericValidateType(allocator, CFAllocatorGetTypeID());
1188     __CFGenericValidateType(name, CFStringGetTypeID());
1189     if (CFEqual(CFSTR(""), name)) {
1190         // empty string is not a time zone name, just abort now,
1191         // following stuff will fail anyway
1192         return NULL;
1193     }
1194     __CFTimeZoneLockGlobal();
1195     if (NULL != __CFTimeZoneCache && CFDictionaryGetValueIfPresent(__CFTimeZoneCache, name, (const void **)&result)) {
1196         __CFTimeZoneUnlockGlobal();
1197         return (CFTimeZoneRef)CFRetain(result);
1198     }
1199     __CFTimeZoneUnlockGlobal();
1200     CFIndex len = CFStringGetLength(name);
1201     if (6 == len || 8 == len) {
1202         UniChar buffer[8];
1203         CFStringGetCharacters(name, CFRangeMake(0, len), buffer);
1204         if ('G' == buffer[0] && 'M' == buffer[1] && 'T' == buffer[2] && ('+' == buffer[3] || '-' == buffer[3])) {
1205             if (('0' <= buffer[4] && buffer[4] <= '9') && ('0' <= buffer[5] && buffer[5] <= '9')) {
1206                 int32_t hours = (buffer[4] - '0') * 10 + (buffer[5] - '0');
1207                 if (-14 <= hours && hours <= 14) {
1208                     CFTimeInterval ti = hours * 3600.0;
1209                     if (6 == len) {
1210                         return CFTimeZoneCreateWithTimeIntervalFromGMT(allocator, ('-' == buffer[3] ? -1.0 : 1.0) * ti);
1211                     } else {
1212                         if (('0' <= buffer[6] && buffer[6] <= '9') && ('0' <= buffer[7] && buffer[7] <= '9')) {
1213                             int32_t minutes = (buffer[6] - '0') * 10 + (buffer[7] - '0');
1214                             if ((-14 == hours && 0 == minutes) || (14 == hours && 0 == minutes) || (0 <= minutes && minutes <= 59)) {
1215                                 ti = ti + minutes * 60.0;
1216                                 return CFTimeZoneCreateWithTimeIntervalFromGMT(allocator, ('-' == buffer[3] ? -1.0 : 1.0) * ti);
1217                             }
1218                         }
1219                     }
1220                 }
1221             }
1222         }
1223     }
1224 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
1225     CFURLRef baseURL, tempURL;
1226     void *bytes;
1227     CFIndex length;
1228
1229 #if DEPLOYMENT_TARGET_WINDOWS_SYNC
1230     if (!__tzZoneInfo) __InitTZStrings();
1231     if (!__tzZoneInfo) return NULL;
1232     baseURL = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, __tzZoneInfo, kCFURLWindowsPathStyle, true);
1233 #else
1234     baseURL = CFURLCreateWithFileSystemPath(kCFAllocatorSystemDefault, CFSTR(TZZONEINFO), kCFURLPOSIXPathStyle, true);
1235 #endif
1236     if (tryAbbrev) {
1237         CFDictionaryRef abbrevs = CFTimeZoneCopyAbbreviationDictionary();
1238         tzName = CFDictionaryGetValue(abbrevs, name);
1239         if (NULL != tzName) {
1240             tempURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL, tzName, false);
1241             if (NULL != tempURL) {
1242                 if (_CFReadBytesFromFile(kCFAllocatorSystemDefault, tempURL, &bytes, &length, 0)) {
1243                     data = CFDataCreateWithBytesNoCopy(kCFAllocatorSystemDefault, bytes, length, kCFAllocatorSystemDefault);
1244                 }
1245                 CFRelease(tempURL);
1246             }
1247         }
1248         CFRelease(abbrevs);
1249     }
1250     if (NULL == data) {
1251         CFDictionaryRef dict = __CFTimeZoneCopyCompatibilityDictionary();
1252         CFStringRef mapping = CFDictionaryGetValue(dict, name);
1253         if (mapping) {
1254             name = mapping;
1255 #if DEPLOYMENT_TARGET_WINDOWS_SYNC
1256         } else if (CFStringHasPrefix(name, __tzZoneInfo)) {
1257             CFMutableStringRef unprefixed = CFStringCreateMutableCopy(kCFAllocatorSystemDefault, CFStringGetLength(name), name);
1258             CFStringDelete(unprefixed, CFRangeMake(0, CFStringGetLength(__tzZoneInfo)));
1259 #else
1260         } else if (CFStringHasPrefix(name, CFSTR(TZZONEINFO))) {
1261             CFMutableStringRef unprefixed = CFStringCreateMutableCopy(kCFAllocatorSystemDefault, CFStringGetLength(name), name);
1262             CFStringDelete(unprefixed, CFRangeMake(0, sizeof(TZZONEINFO)));
1263 #endif
1264             mapping = CFDictionaryGetValue(dict, unprefixed);
1265             if (mapping) {
1266                 name = mapping;
1267             }
1268             CFRelease(unprefixed);
1269         }
1270         CFRelease(dict);
1271         if (CFEqual(CFSTR(""), name)) {
1272             return NULL;
1273         }
1274     }
1275     if (NULL == data) {
1276        tzName = name;
1277        tempURL = CFURLCreateCopyAppendingPathComponent(kCFAllocatorSystemDefault, baseURL, tzName, false);
1278        if (NULL != tempURL) {
1279            if (_CFReadBytesFromFile(kCFAllocatorSystemDefault, tempURL, &bytes, &length, 0)) {
1280                data = CFDataCreateWithBytesNoCopy(kCFAllocatorSystemDefault, bytes, length, kCFAllocatorSystemDefault);
1281            }
1282            CFRelease(tempURL);
1283        }
1284     }
1285     CFRelease(baseURL);
1286     if (NULL != data) {
1287         result = CFTimeZoneCreate(allocator, tzName, data);
1288         if (name != tzName) {
1289             CFStringRef nameCopy = (CFStringRef)CFStringCreateCopy(allocator, name);
1290             __CFTimeZoneLockGlobal();
1291             CFDictionaryAddValue(__CFTimeZoneCache, nameCopy, result);
1292             __CFTimeZoneUnlockGlobal();
1293             CFRelease(nameCopy);
1294         }
1295         CFRelease(data);
1296     }
1297     return result;
1298 }
1299 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
1300 /* Reading GMT offset and daylight flag from the registry
1301  * for TimeZone name
1302  * (Aleksey Dukhnyakov)
1303  */
1304     {
1305         CFStringRef safeName = name;
1306         struct {
1307             LONG Bias;
1308             LONG StandardBias;
1309             LONG DaylightBias;
1310             SYSTEMTIME StandardDate;
1311             SYSTEMTIME DaylightDate;
1312         } tzi;
1313         TIME_ZONE_INFORMATION tzi_system;
1314
1315         HKEY hkResult;
1316         DWORD dwType, dwSize=sizeof(tzi),
1317         dwSize_name1=sizeof(tzi_system.StandardName),
1318         dwSize_name2=sizeof(tzi_system.DaylightName);
1319
1320         if (tryAbbrev) {
1321             CFDictionaryRef abbrevs = CFTimeZoneCopyAbbreviationDictionary();
1322             tzName = (CFStringRef)CFDictionaryGetValue(abbrevs, name);
1323             if (NULL == tzName) {
1324                 CFRelease(abbrevs);
1325                 return NULL;
1326             }
1327             name = tzName;
1328                 CFRelease(abbrevs);
1329         }
1330
1331 /* Open regestry and move down to the TimeZone information
1332  */
1333         if (RegOpenKey(HKEY_LOCAL_MACHINE,_T(TZZONEINFO),&hkResult) !=
1334             ERROR_SUCCESS ) {
1335             return NULL;
1336         }
1337 /* Move down to specific TimeZone name
1338  */
1339 #if defined(UNICODE)
1340         UniChar *uniTimeZone = (UniChar*)CFStringGetCharactersPtr(name);
1341         if (uniTimeZone == NULL) {
1342             // We need to extract the bytes out of the CFStringRef and create our own
1343             // UNICODE string to pass to the Win32 API - RegOpenKey.
1344             UInt8 uniBuff[MAX_PATH+2]; // adding +2 to handle Unicode-null termination /0/0.
1345             CFIndex usedBuff = 0;
1346             CFIndex numChars = CFStringGetBytes(name, CFRangeMake(0, CFStringGetLength(name)), kCFStringEncodingUnicode, 0, FALSE, uniBuff, MAX_PATH, &usedBuff);
1347             if (numChars == 0) {
1348                 return NULL;
1349             } else {
1350                 // NULL-terminate the newly created Unicode string.
1351                 uniBuff[usedBuff] = '\0';
1352                 uniBuff[usedBuff+1] = '\0';
1353             }
1354
1355             if (RegOpenKey(hkResult, (LPCWSTR)uniBuff ,&hkResult) != ERROR_SUCCESS ) {
1356                 return NULL;
1357             }
1358         } else {
1359             if (RegOpenKey(hkResult, (LPCWSTR)uniTimeZone ,&hkResult) != ERROR_SUCCESS ) {
1360                 return NULL;
1361             }
1362         }
1363 #else
1364         if (RegOpenKey(hkResult,CFStringGetCStringPtr(name, CFStringGetSystemEncoding()),&hkResult) != ERROR_SUCCESS ) {
1365             return NULL;
1366         }
1367 #endif
1368
1369 /* TimeZone information(offsets, daylight flag, ...) assign to tzi structure
1370  */
1371         if ( RegQueryValueEx(hkResult,_T("TZI"),NULL,&dwType,(LPBYTE)&tzi,&dwSize) != ERROR_SUCCESS &&
1372             RegQueryValueEx(hkResult,_T("Std"),NULL,&dwType,(LPBYTE)&tzi_system.StandardName,&dwSize_name1) != ERROR_SUCCESS &&
1373             RegQueryValueEx(hkResult,_T("Dlt"),NULL,&dwType,(LPBYTE)&tzi_system.DaylightName,&dwSize_name2) != ERROR_SUCCESS )
1374         {
1375             return NULL;
1376         }
1377
1378         tzi_system.Bias=tzi.Bias;
1379         tzi_system.StandardBias=tzi.StandardBias;
1380         tzi_system.DaylightBias=tzi.DaylightBias;
1381         tzi_system.StandardDate=tzi.StandardDate;
1382         tzi_system.DaylightDate=tzi.DaylightDate;
1383
1384 /* CFTimeZoneRef->_data will contain TIME_ZONE_INFORMATION structure
1385  * to find current timezone
1386  * (Aleksey Dukhnyakov)
1387  */
1388         data = CFDataCreate(allocator,(UInt8 *)&tzi_system, sizeof(tzi_system));
1389
1390         RegCloseKey(hkResult);
1391         result = CFTimeZoneCreate(allocator, name, data);
1392         if (result) {
1393             if (tryAbbrev)
1394                 result->_periods->abbrev = (CFStringRef)CFStringCreateCopy(allocator,safeName);
1395             else {
1396            }
1397         }
1398         CFRelease(data);
1399     }
1400     return result;
1401 }
1402 #else
1403 #error Unknown or unspecified DEPLOYMENT_TARGET
1404 #endif
1405
1406 CFStringRef CFTimeZoneGetName(CFTimeZoneRef tz) {
1407     CF_OBJC_FUNCDISPATCH0(CFTimeZoneGetTypeID(), CFStringRef, tz, "name");
1408     __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
1409     return tz->_name;
1410 }
1411
1412 CFDataRef CFTimeZoneGetData(CFTimeZoneRef tz) {
1413     CF_OBJC_FUNCDISPATCH0(CFTimeZoneGetTypeID(), CFDataRef, tz, "data");
1414     __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
1415     return tz->_data;
1416 }
1417
1418 /* This function converts CFAbsoluteTime to (Win32) SYSTEMTIME
1419  * (Aleksey Dukhnyakov)
1420  */
1421 #if DEPLOYMENT_TARGET_WINDOWS
1422 BOOL __CFTimeZoneGetWin32SystemTime(SYSTEMTIME * sys_time, CFAbsoluteTime time)
1423 {
1424     LONGLONG l;
1425     FILETIME * ftime=(FILETIME*)&l;
1426
1427     /*  seconds between 1601 and 1970 : 11644473600,
1428      *  seconds between 1970 and 2001 : 978307200,
1429      *  FILETIME - number of 100-nanosecond intervals since January 1, 1601
1430      */
1431     l=(LONGLONG)(time+11644473600LL+978307200)*10000000;
1432     if (FileTimeToSystemTime(ftime,sys_time))
1433         return TRUE;
1434     else
1435         return FALSE;
1436 }
1437 #elif DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED
1438 #else
1439 #error Unknown or unspecified DEPLOYMENT_TARGET
1440 #endif
1441
1442 CFTimeInterval CFTimeZoneGetSecondsFromGMT(CFTimeZoneRef tz, CFAbsoluteTime at) {
1443 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
1444     CFIndex idx;
1445     CF_OBJC_FUNCDISPATCH1(CFTimeZoneGetTypeID(), CFTimeInterval, tz, "_secondsFromGMTForAbsoluteTime:", at);
1446     __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
1447     idx = __CFBSearchTZPeriods(tz, at);
1448     return __CFTZPeriodGMTOffset(&(tz->_periods[idx]));
1449 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
1450 /* To calculate seconds from GMT, calculate current timezone time and
1451  * subtract GMT timnezone time
1452  * (Aleksey Dukhnyakov)
1453  */
1454         TIME_ZONE_INFORMATION tzi;
1455         FILETIME ftime1,ftime2;
1456         SYSTEMTIME stime0,stime1,stime2;
1457         LONGLONG * l1= (LONGLONG*)&ftime1;
1458     LONGLONG * l2= (LONGLONG*)&ftime2;
1459     CFRange range={0,sizeof(TIME_ZONE_INFORMATION)};
1460     double result;
1461
1462     CF_OBJC_FUNCDISPATCH1(CFTimeZoneGetTypeID(), CFTimeInterval, tz, "_secondsFromGMTForAbsoluteTime:", at);
1463
1464     CFDataGetBytes(tz->_data,range,(UInt8 *)&tzi);
1465
1466     if (!__CFTimeZoneGetWin32SystemTime(&stime0,at) ||
1467             !SystemTimeToTzSpecificLocalTime(&tzi,&stime0,&stime1) ||
1468                 !SystemTimeToFileTime(&stime1,&ftime1) )
1469         {
1470         CFAssert(0, __kCFLogAssertion, "Win32 system time/timezone failed !\n");
1471                 return 0;
1472         }
1473
1474     tzi.DaylightDate.wMonth=0;
1475         tzi.StandardDate.wMonth=0;
1476     tzi.StandardBias=0;
1477     tzi.DaylightBias=0;
1478     tzi.Bias=0;
1479
1480         if ( !SystemTimeToTzSpecificLocalTime(&tzi,&stime0,&stime2) ||
1481             !SystemTimeToFileTime(&stime2,&ftime2))
1482     {
1483         CFAssert(0, __kCFLogAssertion, "Win32 system time/timezone failed !\n");
1484                 return 0;
1485     }
1486     result=(double)((*l1-*l2)/10000000);
1487         return result;
1488 #else
1489 #error Unknown or unspecified DEPLOYMENT_TARGET
1490 #endif
1491 }
1492
1493 #if DEPLOYMENT_TARGET_WINDOWS_SAFARI
1494 /*
1495  * Get abbreviation for name for WIN32 platform
1496  * (Aleksey Dukhnyakov)
1497  */
1498
1499 typedef struct {
1500     CFStringRef tzName;
1501     CFStringRef tzAbbr;
1502 } _CFAbbrFind;
1503
1504 static void _CFFindKeyForValue(const void *key, const void *value, void *context) {
1505     if ( ((_CFAbbrFind *)context)->tzAbbr != NULL ) {
1506         if ( ((_CFAbbrFind *)context)->tzName == (CFStringRef) value ) {
1507             ((_CFAbbrFind *)context)->tzAbbr = (CFStringRef)key ;
1508         }
1509     }
1510 }
1511
1512 CFIndex __CFTimeZoneInitAbbrev(CFTimeZoneRef tz) {
1513
1514     if ( tz->_periods->abbrev == NULL ) {
1515         _CFAbbrFind abbr = { NULL, NULL };
1516         CFDictionaryRef abbrevs = CFTimeZoneCopyAbbreviationDictionary();
1517
1518         CFDictionaryApplyFunction(abbrevs, _CFFindKeyForValue, &abbr);
1519
1520         if ( abbr.tzAbbr != NULL)
1521             tz->_periods->abbrev = (CFStringRef)CFStringCreateCopy(kCFAllocatorSystemDefault, abbr.tzAbbr);
1522         else
1523             tz->_periods->abbrev = (CFStringRef)CFStringCreateCopy(kCFAllocatorSystemDefault, tz->_name);
1524 /* We should return name of TimeZone if couldn't find abbrevation.
1525  * (Ala on MACOSX)
1526  *
1527  * (Aleksey Dukhnyakov)
1528 */
1529         CFRelease( abbrevs );
1530     }
1531
1532     return 0;
1533 }
1534 #elif DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
1535 #else
1536 #error Unknown or unspecified DEPLOYMENT_TARGET
1537 #endif
1538
1539 CFStringRef CFTimeZoneCopyAbbreviation(CFTimeZoneRef tz, CFAbsoluteTime at) {
1540     CFStringRef result;
1541     CFIndex idx;
1542     CF_OBJC_FUNCDISPATCH1(CFTimeZoneGetTypeID(), CFStringRef, tz, "_abbreviationForAbsoluteTime:", at);
1543     __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
1544 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
1545     idx = __CFBSearchTZPeriods(tz, at);
1546 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
1547 /*
1548  * Initialize abbreviation for this TimeZone
1549  * (Aleksey Dukhnyakov)
1550  */
1551     idx = __CFTimeZoneInitAbbrev(tz);
1552 #else
1553 #error Unknown or unspecified DEPLOYMENT_TARGET
1554 #endif
1555     result = __CFTZPeriodAbbreviation(&(tz->_periods[idx]));
1556     return result ? (CFStringRef)CFRetain(result) : NULL;
1557 }
1558
1559 Boolean CFTimeZoneIsDaylightSavingTime(CFTimeZoneRef tz, CFAbsoluteTime at) {
1560 #if DEPLOYMENT_TARGET_MACOSX || DEPLOYMENT_TARGET_EMBEDDED || DEPLOYMENT_TARGET_WINDOWS_SYNC
1561     CFIndex idx;
1562     CF_OBJC_FUNCDISPATCH1(CFTimeZoneGetTypeID(), Boolean, tz, "_isDaylightSavingTimeForAbsoluteTime:", at);
1563     __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
1564     idx = __CFBSearchTZPeriods(tz, at);
1565     return __CFTZPeriodIsDST(&(tz->_periods[idx]));
1566 #elif DEPLOYMENT_TARGET_WINDOWS_SAFARI
1567 /* Compare current timezone time and current timezone time without
1568  * transition to day light saving time
1569  * (Aleskey Dukhnyakov)
1570  */
1571         TIME_ZONE_INFORMATION tzi;
1572         SYSTEMTIME stime0,stime1,stime2;
1573     CFRange range={0,sizeof(TIME_ZONE_INFORMATION)};
1574
1575     CF_OBJC_FUNCDISPATCH1(CFTimeZoneGetTypeID(), Boolean, tz, "_isDaylightSavingTimeForAbsoluteTime:", at);
1576
1577     CFDataGetBytes(tz->_data,range,(UInt8 *)&tzi);
1578
1579         if ( !__CFTimeZoneGetWin32SystemTime(&stime0,at) ||
1580             !SystemTimeToTzSpecificLocalTime(&tzi,&stime0,&stime1)) {
1581         CFAssert(0, __kCFLogAssertion, "Win32 system time/timezone failed !\n");
1582                 return FALSE;
1583     }
1584
1585     tzi.DaylightDate.wMonth=0;
1586         tzi.StandardDate.wMonth=0;
1587
1588         if ( !SystemTimeToTzSpecificLocalTime(&tzi,&stime0,&stime2)) {
1589         CFAssert(0, __kCFLogAssertion, "Win32 system time/timezone failed !\n");
1590                 return FALSE;
1591     }
1592
1593     if ( !memcmp(&stime1,&stime2,sizeof(stime1)) )
1594         return FALSE;
1595
1596     return TRUE;
1597 #else
1598 #error Unknown or unspecified DEPLOYMENT_TARGET
1599 #endif
1600 }
1601
1602 CFTimeInterval CFTimeZoneGetDaylightSavingTimeOffset(CFTimeZoneRef tz, CFAbsoluteTime at) {
1603     CF_OBJC_FUNCDISPATCH1(CFTimeZoneGetTypeID(), CFTimeInterval, tz, "_daylightSavingTimeOffsetForAbsoluteTime:", at);
1604     __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
1605     CFIndex idx = __CFBSearchTZPeriods(tz, at);
1606     if (__CFTZPeriodIsDST(&(tz->_periods[idx]))) {
1607         CFTimeInterval offset = __CFTZPeriodGMTOffset(&(tz->_periods[idx]));
1608         if (idx + 1 < tz->_periodCnt) {
1609             return offset - __CFTZPeriodGMTOffset(&(tz->_periods[idx + 1]));
1610         } else if (0 < idx) {
1611             return offset - __CFTZPeriodGMTOffset(&(tz->_periods[idx - 1]));
1612         }
1613     }
1614     return 0.0;
1615 }
1616
1617 CFAbsoluteTime CFTimeZoneGetNextDaylightSavingTimeTransition(CFTimeZoneRef tz, CFAbsoluteTime at) {
1618     CF_OBJC_FUNCDISPATCH1(CFTimeZoneGetTypeID(), CFTimeInterval, tz, "_nextDaylightSavingTimeTransitionAfterAbsoluteTime:", at);
1619     __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
1620     CFIndex idx = __CFBSearchTZPeriods(tz, at);
1621     if (tz->_periodCnt <= idx + 1) {
1622         return 0.0;
1623     }
1624     return (CFAbsoluteTime)__CFTZPeriodStartSeconds(&(tz->_periods[idx + 1]));
1625 }
1626
1627 extern UCalendar *__CFCalendarCreateUCalendar(CFStringRef calendarID, CFStringRef localeID, CFTimeZoneRef tz);
1628
1629 #define BUFFER_SIZE 768
1630
1631 CFStringRef CFTimeZoneCopyLocalizedName(CFTimeZoneRef tz, CFTimeZoneNameStyle style, CFLocaleRef locale) {
1632     CF_OBJC_FUNCDISPATCH2(CFTimeZoneGetTypeID(), CFStringRef, tz, "localizedName:locale:", style, locale);
1633     __CFGenericValidateType(tz, CFTimeZoneGetTypeID());
1634     __CFGenericValidateType(locale, CFLocaleGetTypeID());
1635
1636     if (style == kCFTimeZoneNameStyleGeneric || style == kCFTimeZoneNameStyleShortGeneric) {
1637         CFDateFormatterRef df = CFDateFormatterCreate(kCFAllocatorSystemDefault, locale, kCFDateFormatterNoStyle, kCFDateFormatterNoStyle);
1638         CFDateFormatterSetProperty(df, kCFDateFormatterTimeZone, tz);
1639         CFDateFormatterSetFormat(df, (style == kCFTimeZoneNameStyleGeneric) ? CFSTR("vvvv") : CFSTR("v"));
1640         CFStringRef str = CFDateFormatterCreateStringWithAbsoluteTime(CFGetAllocator(tz), df, 0.0);
1641         CFRelease(df);
1642         return str;
1643     }
1644
1645     CFStringRef localeID = CFLocaleGetIdentifier(locale);
1646     UCalendar *cal = __CFCalendarCreateUCalendar(NULL, localeID, tz);
1647     if (NULL == cal) {
1648         return NULL;
1649     }
1650
1651     char buffer[BUFFER_SIZE];
1652     const char *cstr = CFStringGetCStringPtr(localeID, kCFStringEncodingASCII);
1653     if (NULL == cstr) {
1654         if (CFStringGetCString(localeID, buffer, BUFFER_SIZE, kCFStringEncodingASCII)) cstr = buffer;
1655     }
1656     if (NULL == cstr) {
1657         ucal_close(cal);
1658         return NULL;
1659     }
1660
1661     UChar ubuffer[BUFFER_SIZE];
1662     UErrorCode status = U_ZERO_ERROR;
1663     int32_t cnt = ucal_getTimeZoneDisplayName(cal, (UCalendarDisplayNameType)style, cstr, ubuffer, BUFFER_SIZE, &status);
1664     ucal_close(cal);
1665     if (U_SUCCESS(status) && cnt <= BUFFER_SIZE) {
1666         return CFStringCreateWithCharacters(CFGetAllocator(tz), (const UniChar *)ubuffer, cnt);
1667     }
1668     return NULL;
1669 }
1670
1671 static CFDictionaryRef __CFTimeZoneCopyCompatibilityDictionary(void) {
1672     CFDictionaryRef dict;
1673     __CFTimeZoneLockCompatibilityMapping();
1674     if (NULL == __CFTimeZoneCompatibilityMappingDict) {
1675         __CFTimeZoneCompatibilityMappingDict = CFDictionaryCreateMutable(kCFAllocatorSystemDefault, 112, &kCFTypeDictionaryKeyCallBacks, &kCFTypeDictionaryValueCallBacks);
1676
1677         // Empty string means delete/ignore these
1678     }
1679     dict = __CFTimeZoneCompatibilityMappingDict ? (CFDictionaryRef)CFRetain(__CFTimeZoneCompatibilityMappingDict) : NULL;
1680     __CFTimeZoneUnlockCompatibilityMapping();
1681     return dict;
1682 }
1683
1684 #undef TZZONEINFO
1685 #undef TZZONELINK
1686