glib/gtimezone.c

   1 /*
   2  * Copyright © 2010 Codethink Limited
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2 of the licence, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, write to the
  16  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  17  * Boston, MA 02111-1307, USA.
  18  *
  19  * Author: Ryan Lortie <desrt@desrt.ca>
  20  */
  21
  22 /* Prologue {{{1 */
  23
  24 #include "config.h"
  25
  26 #include "gtimezone.h"
  27
  28 #include <string.h>
  29 #include <stdlib.h>
  30 #include <signal.h>
  31
  32 #include "gmappedfile.h"
  33 #include "gtestutils.h"
  34 #include "gfileutils.h"
  35 #include "gstrfuncs.h"
  36 #include "ghash.h"
  37 #include "gthread.h"
  38 #include "gbytes.h"
  39 #include "gslice.h"
  40 #include "gdatetime.h"
  41 #include "gdate.h"
  42
  43 #ifdef G_OS_WIN32
  44 #define STRICT
  45 #include <windows.h>
  46 #endif
  47
  48 /**
  49  * SECTION:timezone
  50  * @title: GTimeZone
  51  * @short_description: a structure representing a time zone
  52  * @see_also: #GDateTime
  53  *
  54  * #GTimeZone is a structure that represents a time zone, at no
  55  * particular point in time.  It is refcounted and immutable.
  56  *
  57  * A time zone contains a number of intervals.  Each interval has
  58  * an abbreviation to describe it, an offet to UTC and a flag indicating
  59  * if the daylight savings time is in effect during that interval.  A
  60  * time zone always has at least one interval -- interval 0.
  61  *
  62  * Every UTC time is contained within exactly one interval, but a given
  63  * local time may be contained within zero, one or two intervals (due to
  64  * incontinuities associated with daylight savings time).
  65  *
  66  * An interval may refer to a specific period of time (eg: the duration
  67  * of daylight savings time during 2010) or it may refer to many periods
  68  * of time that share the same properties (eg: all periods of daylight
  69  * savings time).  It is also possible (usually for political reasons)
  70  * that some properties (like the abbreviation) change between intervals
  71  * without other properties changing.
  72  *
  73  * #GTimeZone is available since GLib 2.26.
  74  */
  75
  76 /**
  77  * GTimeZone:
  78  *
  79  * #GDateTime is an opaque structure whose members cannot be accessed
  80  * directly.
  81  *
  82  * Since: 2.26
  83  **/
  84
  85 /* IANA zoneinfo file format {{{1 */
  86
  87 /* unaligned */
  88 typedef struct { gchar bytes[8]; } gint64_be;
  89 typedef struct { gchar bytes[4]; } gint32_be;
  90 typedef struct { gchar bytes[4]; } guint32_be;
  91
  92 static inline gint64 gint64_from_be (const gint64_be be) {
  93   gint64 tmp; memcpy (&tmp, &be, sizeof tmp); return GINT64_FROM_BE (tmp);
  94 }
  95
  96 static inline gint32 gint32_from_be (const gint32_be be) {
  97   gint32 tmp; memcpy (&tmp, &be, sizeof tmp); return GINT32_FROM_BE (tmp);
  98 }
  99
 100 static inline guint32 guint32_from_be (const guint32_be be) {
 101   guint32 tmp; memcpy (&tmp, &be, sizeof tmp); return GUINT32_FROM_BE (tmp);
 102 }
 103
 104 /* The layout of an IANA timezone file header */
 105 struct tzhead
 106 {
 107   gchar      tzh_magic[4];
 108   gchar      tzh_version;
 109   guchar     tzh_reserved[15];
 110
 111   guint32_be tzh_ttisgmtcnt;
 112   guint32_be tzh_ttisstdcnt;
 113   guint32_be tzh_leapcnt;
 114   guint32_be tzh_timecnt;
 115   guint32_be tzh_typecnt;
 116   guint32_be tzh_charcnt;
 117 };
 118
 119 struct ttinfo
 120 {
 121   gint32_be tt_gmtoff;
 122   guint8    tt_isdst;
 123   guint8    tt_abbrind;
 124 };
 125
 126 /* A Transition Date structure for TZ Rules, an intermediate structure
 127    for parsing MSWindows and Environment-variable time zones. It
 128    Generalizes MSWindows's SYSTEMTIME struct.
 129  */
 130 typedef struct
 131 {
 132   gint     year;
 133   gint     mon;
 134   gint     mday;
 135   gint     wday;
 136   gint     week;
 137   gint     hour;
 138   gint     min;
 139   gint     sec;
 140 } TimeZoneDate;
 141
 142 /* POSIX Timezone abbreviations are typically 3 or 4 characters, but
 143    Microsoft uses 32-character names. We'll use one larger to ensure
 144    we have room for the terminating \0.
 145  */
 146 #define NAME_SIZE 33
 147
 148 /* A MSWindows-style time zone transition rule. Generalizes the
 149    MSWindows TIME_ZONE_INFORMATION struct. Also used to compose time
 150    zones from tzset-style identifiers.
 151  */
 152 typedef struct
 153 {
 154   gint         start_year;
 155   gint32       std_offset;
 156   gint32       dlt_offset;
 157   TimeZoneDate dlt_start;
 158   TimeZoneDate dlt_end;
 159   gchar std_name[NAME_SIZE];
 160   gchar dlt_name[NAME_SIZE];
 161 } TimeZoneRule;
 162
 163 /* GTimeZone's internal representation of a Daylight Savings (Summer)
 164    time interval.
 165  */
 166 typedef struct
 167 {
 168   gint32     gmt_offset;
 169   gboolean   is_dst;
 170   gboolean   is_standard;
 171   gboolean   is_gmt;
 172   gchar     *abbrev;
 173 } TransitionInfo;
 174
 175 /* GTimeZone's representation of a transition time to or from Daylight
 176    Savings (Summer) time and Standard time for the zone. */
 177 typedef struct
 178 {
 179   gint64 time;
 180   gint   info_index;
 181 } Transition;
 182
 183 /* GTimeZone structure */
 184 struct _GTimeZone
 185 {
 186   gchar   *name;
 187   GArray  *t_info;         /* Array of TransitionInfo */
 188   GArray  *transitions;    /* Array of Transition */
 189   gint     ref_count;
 190 };
 191
 192 G_LOCK_DEFINE_STATIC (time_zones);
 193 static GHashTable/*<string?, GTimeZone>*/ *time_zones;
 194
 195 #define MIN_TZYEAR 1916 /* Daylight Savings started in WWI */
 196 #define MAX_TZYEAR 2999 /* And it's not likely ever to go away, but
 197                            there's no point in getting carried
 198                            away. */
 199
 200 /**
 201  * g_time_zone_unref:
 202  * @tz: a #GTimeZone
 203  *
 204  * Decreases the reference count on @tz.
 205  *
 206  * Since: 2.26
 207  **/
 208 void
 209 g_time_zone_unref (GTimeZone *tz)
 210 {
 211   int ref_count;
 212
 213 again:
 214   ref_count = g_atomic_int_get (&tz->ref_count);
 215
 216   g_assert (ref_count > 0);
 217
 218   if (ref_count == 1)
 219     {
 220       if (tz->name != NULL)
 221         {
 222           G_LOCK(time_zones);
 223
 224           /* someone else might have grabbed a ref in the meantime */
 225           if G_UNLIKELY (g_atomic_int_get (&tz->ref_count) != 1)
 226             {
 227               G_UNLOCK(time_zones);
 228               goto again;
 229             }
 230
 231           g_hash_table_remove (time_zones, tz->name);
 232           G_UNLOCK(time_zones);
 233         }
 234
 235       if (tz->t_info != NULL)
 236         g_array_free (tz->t_info, TRUE);
 237       if (tz->transitions != NULL)
 238         g_array_free (tz->transitions, TRUE);
 239       g_free (tz->name);
 240
 241       g_slice_free (GTimeZone, tz);
 242     }
 243
 244   else if G_UNLIKELY (!g_atomic_int_compare_and_exchange (&tz->ref_count,
 245                                                           ref_count,
 246                                                           ref_count - 1))
 247     goto again;
 248 }
 249
 250 /**
 251  * g_time_zone_ref:
 252  * @tz: a #GTimeZone
 253  *
 254  * Increases the reference count on @tz.
 255  *
 256  * Returns: a new reference to @tz.
 257  *
 258  * Since: 2.26
 259  **/
 260 GTimeZone *
 261 g_time_zone_ref (GTimeZone *tz)
 262 {
 263   g_assert (tz->ref_count > 0);
 264
 265   g_atomic_int_inc (&tz->ref_count);
 266
 267   return tz;
 268 }
 269
 270 /* fake zoneinfo creation (for RFC3339/ISO 8601 timezones) {{{1 */
 271 /*
 272  * parses strings of the form h or hh[[:]mm[[[:]ss]]] where:
 273  *  - h[h] is 0 to 23
 274  *  - mm is 00 to 59
 275  *  - ss is 00 to 59
 276  */
 277 static gboolean
 278 parse_time (const gchar *time_,
 279             gint32      *offset)
 280 {
 281   if (*time_ < '0' || '9' < *time_)
 282     return FALSE;
 283
 284   *offset = 60 * 60 * (*time_++ - '0');
 285
 286   if (*time_ == '\0')
 287     return TRUE;
 288
 289   if (*time_ != ':')
 290     {
 291       if (*time_ < '0' || '9' < *time_)
 292         return FALSE;
 293
 294       *offset *= 10;
 295       *offset += 60 * 60 * (*time_++ - '0');
 296
 297       if (*offset > 23 * 60 * 60)
 298         return FALSE;
 299
 300       if (*time_ == '\0')
 301         return TRUE;
 302     }
 303
 304   if (*time_ == ':')
 305     time_++;
 306
 307   if (*time_ < '0' || '5' < *time_)
 308     return FALSE;
 309
 310   *offset += 10 * 60 * (*time_++ - '0');
 311
 312   if (*time_ < '0' || '9' < *time_)
 313     return FALSE;
 314
 315   *offset += 60 * (*time_++ - '0');
 316
 317   if (*time_ == '\0')
 318     return TRUE;
 319
 320   if (*time_ == ':')
 321     time_++;
 322
 323   if (*time_ < '0' || '5' < *time_)
 324     return FALSE;
 325
 326   *offset += 10 * (*time_++ - '0');
 327
 328   if (*time_ < '0' || '9' < *time_)
 329     return FALSE;
 330
 331   *offset += *time_++ - '0';
 332
 333   return *time_ == '\0';
 334 }
 335
 336 static gboolean
 337 parse_constant_offset (const gchar *name,
 338                        gint32      *offset)
 339 {
 340   if (g_strcmp0 (name, "UTC") == 0)
 341     {
 342       *offset = 0;
 343       return TRUE;
 344     }
 345
 346   if (*name >= '0' && '9' >= *name)
 347     return parse_time (name, offset);
 348
 349   switch (*name++)
 350     {
 351     case 'Z':
 352       *offset = 0;
 353       return !*name;
 354
 355     case '+':
 356       return parse_time (name, offset);
 357
 358     case '-':
 359       if (parse_time (name, offset))
 360         {
 361           *offset = -*offset;
 362           return TRUE;
 363         }
 364
 365     default:
 366       return FALSE;
 367     }
 368 }
 369
 370 static void
 371 zone_for_constant_offset (GTimeZone *gtz, const gchar *name)
 372 {
 373   gint32 offset;
 374   TransitionInfo info;
 375
 376   if (name == NULL || !parse_constant_offset (name, &offset))
 377     return;
 378
 379   info.gmt_offset = offset;
 380   info.is_dst = FALSE;
 381   info.is_standard = TRUE;
 382   info.is_gmt = TRUE;
 383   info.abbrev =  g_strdup (name);
 384
 385
 386   gtz->t_info = g_array_sized_new (FALSE, TRUE, sizeof (TransitionInfo), 1);
 387   g_array_append_val (gtz->t_info, info);
 388
 389   /* Constant offset, no transitions */
 390   gtz->transitions = NULL;
 391 }
 392
 393 #ifdef G_OS_UNIX
 394 static GBytes*
 395 zone_info_unix (const gchar *identifier)
 396 {
 397   gchar *filename;
 398   GMappedFile *file = NULL;
 399   GBytes *zoneinfo = NULL;
 400
 401   /* identifier can be a relative or absolute path name;
 402      if relative, it is interpreted starting from /usr/share/zoneinfo
 403      while the POSIX standard says it should start with :,
 404      glibc allows both syntaxes, so we should too */
 405   if (identifier != NULL)
 406     {
 407       const gchar *tzdir;
 408
 409       tzdir = getenv ("TZDIR");
 410       if (tzdir == NULL)
 411         tzdir = "/usr/share/zoneinfo";
 412
 413       if (*identifier == ':')
 414         identifier ++;
 415
 416       if (g_path_is_absolute (identifier))
 417         filename = g_strdup (identifier);
 418       else
 419         filename = g_build_filename (tzdir, identifier, NULL);
 420     }
 421   else
 422     filename = g_strdup ("/etc/localtime");
 423
 424   file = g_mapped_file_new (filename, FALSE, NULL);
 425   if (file != NULL)
 426     {
 427       zoneinfo = g_bytes_new_with_free_func (g_mapped_file_get_contents (file),
 428                                              g_mapped_file_get_length (file),
 429                                              (GDestroyNotify)g_mapped_file_unref,
 430                                              g_mapped_file_ref (file));
 431       g_mapped_file_unref (file);
 432     }
 433   g_free (filename);
 434   return zoneinfo;
 435 }
 436
 437 static void
 438 init_zone_from_iana_info (GTimeZone *gtz, GBytes *zoneinfo)
 439 {
 440   gsize size;
 441   guint index;
 442   guint32 time_count, type_count, leap_count, isgmt_count;
 443   guint32  isstd_count, char_count ;
 444   guint8 *tz_transitions, *tz_type_index, *tz_ttinfo;
 445   guint8 *tz_leaps, *tz_isgmt, *tz_isstd;
 446   guint8 *tz_abbrs;
 447   gsize timesize = sizeof (gint32), countsize = sizeof (gint32);
 448   const struct tzhead *header = g_bytes_get_data (zoneinfo, &size);
 449
 450   g_return_if_fail (size >= sizeof (struct tzhead) &&
 451                     memcmp (header, "TZif", 4) == 0);
 452
 453   if (header->tzh_version == '2')
 454       {
 455         /* Skip ahead to the newer 64-bit data if it's available. */
 456         header = (const struct tzhead *)
 457           (((const gchar *) (header + 1)) +
 458            guint32_from_be(header->tzh_ttisgmtcnt) +
 459            guint32_from_be(header->tzh_ttisstdcnt) +
 460            8 * guint32_from_be(header->tzh_leapcnt) +
 461            5 * guint32_from_be(header->tzh_timecnt) +
 462            6 * guint32_from_be(header->tzh_typecnt) +
 463            guint32_from_be(header->tzh_charcnt));
 464         timesize = sizeof (gint64);
 465       }
 466   time_count = guint32_from_be(header->tzh_timecnt);
 467   type_count = guint32_from_be(header->tzh_typecnt);
 468   leap_count = guint32_from_be(header->tzh_leapcnt);
 469   isgmt_count = guint32_from_be(header->tzh_ttisgmtcnt);
 470   isstd_count = guint32_from_be(header->tzh_ttisstdcnt);
 471   char_count = guint32_from_be(header->tzh_charcnt);
 472
 473   g_assert (type_count == isgmt_count);
 474   g_assert (type_count == isstd_count);
 475
 476   tz_transitions = ((guint8 *) (header) + sizeof (*header));
 477   tz_type_index = tz_transitions + timesize * time_count;
 478   tz_ttinfo = tz_type_index + time_count;
 479   tz_abbrs = tz_ttinfo + sizeof (struct ttinfo) * type_count;
 480   tz_leaps = tz_abbrs + char_count;
 481   tz_isstd = tz_leaps + (timesize + countsize) * leap_count;
 482   tz_isgmt = tz_isstd + isstd_count;
 483
 484   gtz->t_info = g_array_sized_new (FALSE, TRUE, sizeof (TransitionInfo),
 485                                    type_count);
 486   gtz->transitions = g_array_sized_new (FALSE, TRUE, sizeof (Transition),
 487                                         time_count);
 488
 489   for (index = 0; index < type_count; index++)
 490     {
 491       TransitionInfo t_info;
 492       struct ttinfo info = ((struct ttinfo*)tz_ttinfo)[index];
 493       t_info.gmt_offset = gint32_from_be (info.tt_gmtoff);
 494       t_info.is_dst = info.tt_isdst ? TRUE : FALSE;
 495       t_info.is_standard = tz_isstd[index] ? TRUE : FALSE;
 496       t_info.is_gmt = tz_isgmt[index] ? TRUE : FALSE;
 497       t_info.abbrev = g_strdup ((gchar *) &tz_abbrs[info.tt_abbrind]);
 498       g_array_append_val (gtz->t_info, t_info);
 499     }
 500
 501   for (index = 0; index < time_count; index++)
 502     {
 503       Transition trans;
 504       if (header->tzh_version == '2')
 505         trans.time = gint64_from_be (((gint64_be*)tz_transitions)[index]);
 506       else
 507         trans.time = gint32_from_be (((gint32_be*)tz_transitions)[index]);
 508       trans.info_index = tz_type_index[index];
 509       g_assert (trans.info_index >= 0);
 510       g_assert (trans.info_index < gtz->t_info->len);
 511       g_array_append_val (gtz->transitions, trans);
 512     }
 513   g_bytes_unref (zoneinfo);
 514 }
 515
 516 #elif defined (G_OS_WIN32)
 517
 518 static void
 519 copy_windows_systemtime (SYSTEMTIME *s_time, TimeZoneDate *tzdate)
 520 {
 521   tzdate->sec = s_time->wSecond;
 522   tzdate->min = s_time->wMinute;
 523   tzdate->hour = s_time->wHour;
 524   tzdate->mon = s_time->wMonth;
 525   tzdate->year = s_time->wYear;
 526   tzdate->wday = s_time->wDayOfWeek ? s_time->wDayOfWeek : 7;
 527
 528   if (s_time->wYear)
 529     {
 530       tzdate->mday = s_time->wDay;
 531       tzdate->wday = 0;
 532     }
 533   else
 534     tzdate->week = s_time->wDay;
 535 }
 536
 537 /* UTC = local time + bias while local time = UTC + offset */
 538 static void
 539 rule_from_windows_time_zone_info (TimeZoneRule *rule,
 540                                   TIME_ZONE_INFORMATION *tzi)
 541 {
 542   /* Set offset */
 543   if (tzi->StandardDate.wMonth)
 544     {
 545       rule->std_offset = -(tzi->Bias + tzi->StandardBias) * 60;
 546       rule->dlt_offset = -(tzi->Bias + tzi->DaylightBias) * 60;
 547       copy_windows_systemtime (&(tzi->DaylightDate), &(rule->dlt_start));
 548
 549       copy_windows_systemtime (&(tzi->StandardDate), &(rule->dlt_end));
 550
 551     }
 552
 553   else
 554     {
 555       rule->std_offset = -tzi->Bias * 60;
 556       rule->dlt_start.mon = 0;
 557     }
 558   strncpy (rule->std_name, (gchar*)tzi->StandardName, NAME_SIZE - 1);
 559   strncpy (rule->dlt_name, (gchar*)tzi->DaylightName, NAME_SIZE - 1);
 560 }
 561
 562 static gchar*
 563 windows_default_tzname (void)
 564 {
 565   const gchar *subkey =
 566     "SYSTEM\\CurrentControlSet\\Control\\TimeZoneInformation";
 567   HKEY key;
 568   gchar *key_name = NULL;
 569   if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, subkey, 0,
 570                      KEY_QUERY_VALUE, &key) == ERROR_SUCCESS)
 571     {
 572       DWORD size = 0;
 573       if (RegQueryValueExA (key, "TimeZoneKeyName", NULL, NULL,
 574                             NULL, &size) == ERROR_SUCCESS)
 575         {
 576           key_name = g_malloc ((gint)size);
 577           if (RegQueryValueExA (key, "TimeZoneKeyName", NULL, NULL,
 578                                 (LPBYTE)key_name, &size) != ERROR_SUCCESS)
 579             {
 580               g_free (key_name);
 581               key_name = NULL;
 582             }
 583         }
 584       RegCloseKey (key);
 585     }
 586   return key_name;
 587 }
 588
 589 typedef   struct
 590 {
 591   LONG Bias;
 592   LONG StandardBias;
 593   LONG DaylightBias;
 594   SYSTEMTIME StandardDate;
 595   SYSTEMTIME DaylightDate;
 596 } RegTZI;
 597
 598 static void
 599 system_time_copy (SYSTEMTIME *orig, SYSTEMTIME *target)
 600 {
 601   g_return_if_fail (orig != NULL);
 602   g_return_if_fail (target != NULL);
 603
 604   target->wYear = orig->wYear;
 605   target->wMonth = orig->wMonth;
 606   target->wDayOfWeek = orig->wDayOfWeek;
 607   target->wDay = orig->wDay;
 608   target->wHour = orig->wHour;
 609   target->wMinute = orig->wMinute;
 610   target->wSecond = orig->wSecond;
 611   target->wMilliseconds = orig->wMilliseconds;
 612 }
 613
 614 static void
 615 register_tzi_to_tzi (RegTZI *reg, TIME_ZONE_INFORMATION *tzi)
 616 {
 617   g_return_if_fail (reg != NULL);
 618   g_return_if_fail (tzi != NULL);
 619   tzi->Bias = reg->Bias;
 620   system_time_copy (&(reg->StandardDate), &(tzi->StandardDate));
 621   tzi->StandardBias = reg->StandardBias;
 622   system_time_copy (&(reg->DaylightDate), &(tzi->DaylightDate));
 623   tzi->DaylightBias = reg->DaylightBias;
 624 }
 625
 626 static gint
 627 rules_from_windows_time_zone (const gchar *identifier, TimeZoneRule **rules)
 628 {
 629   HKEY key;
 630   gchar *subkey, *subkey_dynamic;
 631   gchar *key_name = NULL;
 632   const gchar *reg_key =
 633     "SOFTWARE\\Microsoft\\Windows NT\\CurrentVersion\\Time Zones\\";
 634   TIME_ZONE_INFORMATION tzi;
 635   DWORD size;
 636   gint rules_num = 0;
 637   RegTZI regtzi, regtzi_prev;
 638
 639   *rules = NULL;
 640   key_name = NULL;
 641
 642   if (!identifier)
 643     key_name = windows_default_tzname ();
 644   else
 645     key_name = g_strdup (identifier);
 646
 647   if (!key_name)
 648     return 0;
 649
 650   subkey = g_strconcat (reg_key, key_name, NULL);
 651   subkey_dynamic = g_strconcat (subkey, "\\Dynamic DST", NULL);
 652
 653   if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, subkey, 0,
 654                      KEY_QUERY_VALUE, &key) != ERROR_SUCCESS)
 655       return 0;
 656   size = sizeof tzi.StandardName;
 657   if (RegQueryValueExA (key, "Std", NULL, NULL,
 658                         (LPBYTE)&(tzi.StandardName), &size) != ERROR_SUCCESS)
 659     goto failed;
 660   if (RegQueryValueExA (key, "Dlt", NULL, NULL,
 661                         (LPBYTE)&(tzi.DaylightName), &size) != ERROR_SUCCESS)
 662     goto failed;
 663
 664   RegCloseKey (key);
 665   if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, subkey_dynamic, 0,
 666                      KEY_QUERY_VALUE, &key) == ERROR_SUCCESS)
 667     {
 668       DWORD first, last;
 669       int year, i;
 670       gchar *s;
 671
 672       size = sizeof first;
 673       if (RegQueryValueExA (key, "FirstEntry", NULL, NULL,
 674                             (LPBYTE) &first, &size) != ERROR_SUCCESS)
 675         goto failed;
 676
 677       size = sizeof last;
 678       if (RegQueryValueExA (key, "LastEntry", NULL, NULL,
 679                             (LPBYTE) &last, &size) != ERROR_SUCCESS)
 680         goto failed;
 681
 682       rules_num = last - first + 2;
 683       *rules = g_new0 (TimeZoneRule, rules_num);
 684
 685       for (year = first, i = 0; year <= last; year++)
 686         {
 687           s = g_strdup_printf ("%d", year);
 688
 689           size = sizeof regtzi;
 690           if (RegQueryValueExA (key, s, NULL, NULL,
 691                             (LPBYTE) &regtzi, &size) != ERROR_SUCCESS)
 692             {
 693               g_free (*rules);
 694               *rules = NULL;
 695               break;
 696             }
 697
 698           g_free (s);
 699
 700           if (year > first && memcmp (&regtzi_prev, &regtzi, sizeof regtzi) == 0)
 701               continue;
 702           else
 703             memcpy (&regtzi_prev, &regtzi, sizeof regtzi);
 704
 705           register_tzi_to_tzi (&regtzi, &tzi);
 706           rule_from_windows_time_zone_info (&(*rules)[i], &tzi);
 707           (*rules)[i++].start_year = year;
 708         }
 709
 710       rules_num = i + 1;
 711
 712 failed:
 713       RegCloseKey (key);
 714     }
 715   else if (RegOpenKeyExA (HKEY_LOCAL_MACHINE, subkey, 0,
 716                           KEY_QUERY_VALUE, &key) == ERROR_SUCCESS)
 717     {
 718       size = sizeof regtzi;
 719       if (RegQueryValueExA (key, "TZI", NULL, NULL,
 720                             (LPBYTE) &regtzi, &size) == ERROR_SUCCESS)
 721         {
 722           rules_num = 2;
 723           *rules = g_new0 (TimeZoneRule, 2);
 724           register_tzi_to_tzi (&regtzi, &tzi);
 725           rule_from_windows_time_zone_info (&(*rules)[0], &tzi);
 726         }
 727
 728       RegCloseKey (key);
 729     }
 730
 731   g_free (subkey_dynamic);
 732   g_free (subkey);
 733   g_free (key_name);
 734
 735   if (*rules)
 736     {
 737       (*rules)[0].start_year = MIN_TZYEAR;
 738       if ((*rules)[rules_num - 2].start_year < MAX_TZYEAR)
 739         (*rules)[rules_num - 1].start_year = MAX_TZYEAR;
 740       else
 741         (*rules)[rules_num - 1].start_year = (*rules)[rules_num - 2].start_year + 1;
 742
 743       return rules_num;
 744     }
 745   else
 746     return 0;
 747 }
 748
 749 #endif
 750
 751 static void
 752 find_relative_date (TimeZoneDate *buffer)
 753 {
 754   gint wday;
 755   GDate date;
 756   g_date_clear (&date, 1);
 757   wday = buffer->wday;
 758
 759   /* Get last day if last is needed, first day otherwise */
 760   if (buffer->mon == 13 || buffer->mon == 14) /* Julian Date */
 761     {
 762       g_date_set_dmy (&date, 1, 1, buffer->year);
 763       if (wday >= 59 && buffer->mon == 13 && g_date_is_leap_year (buffer->year))
 764         g_date_add_days (&date, wday);
 765       else
 766         g_date_add_days (&date, wday - 1);
 767       buffer->mon = (int) g_date_get_month (&date);
 768       buffer->mday = (int) g_date_get_day (&date);
 769       buffer->wday = 0;
 770     }
 771   else /* M.W.D */
 772     {
 773       guint days;
 774       guint days_in_month = g_date_days_in_month (buffer->mon, buffer->year);
 775       GDateWeekday first_wday;
 776
 777       g_date_set_dmy (&date, 1, buffer->mon, buffer->year);
 778       first_wday = g_date_get_weekday (&date);
 779
 780       if (first_wday > wday)
 781         ++(buffer->week);
 782       /* week is 1 <= w <= 5, we need 0-based */
 783       days = 7 * (buffer->week - 1) + wday - first_wday;
 784
 785       while (days > days_in_month)
 786         days -= 7;
 787
 788       g_date_add_days (&date, days);
 789
 790       buffer->mday = g_date_get_day (&date);
 791     }
 792 }
 793
 794 /* Offset is previous offset of local time. Returns 0 if month is 0 */
 795 static gint64
 796 boundary_for_year (TimeZoneDate *boundary,
 797                    gint          year,
 798                    gint32        offset)
 799 {
 800   TimeZoneDate buffer;
 801   GDate date;
 802   const guint64 unix_epoch_start = 719163L;
 803   const guint64 seconds_per_day = 86400L;
 804
 805   if (!boundary->mon)
 806     return 0;
 807   buffer = *boundary;
 808
 809   if (boundary->year == 0)
 810     {
 811       buffer.year = year;
 812
 813       if (buffer.wday)
 814         find_relative_date (&buffer);
 815     }
 816
 817   g_assert (buffer.year == year);
 818   g_date_clear (&date, 1);
 819   g_date_set_dmy (&date, buffer.mday, buffer.mon, buffer.year);
 820   return ((g_date_get_julian (&date) - unix_epoch_start) * seconds_per_day +
 821           buffer.hour * 3600 + buffer.min * 60 + buffer.sec - offset);
 822 }
 823
 824 static void
 825 fill_transition_info_from_rule (TransitionInfo *info,
 826                                 TimeZoneRule   *rule,
 827                                 gboolean        is_dst)
 828 {
 829   gint offset = is_dst ? rule->dlt_offset : rule->std_offset;
 830   gchar *name = is_dst ? rule->dlt_name : rule->std_name;
 831
 832   info->gmt_offset = offset;
 833   info->is_dst = is_dst;
 834   info->is_standard = FALSE;
 835   info->is_gmt = FALSE;
 836
 837   if (name)
 838     info->abbrev = g_strdup (name);
 839
 840   else
 841     info->abbrev = g_strdup_printf ("%+03d%02d",
 842                                       (int) offset / 3600,
 843                                       (int) abs (offset / 60) % 60);
 844 }
 845
 846 static void
 847 init_zone_from_rules (GTimeZone    *gtz,
 848                       TimeZoneRule *rules,
 849                       gint          rules_num)
 850 {
 851   guint type_count = 0, trans_count = 0, info_index = 0;
 852   guint ri; /* rule index */
 853   gboolean skip_first_std_trans = TRUE;
 854   gint32 last_offset;
 855
 856   type_count = 0;
 857   trans_count = 0;
 858
 859   /* Last rule only contains max year */
 860   for (ri = 0; ri < rules_num - 1; ri++)
 861     {
 862       if (rules[ri].dlt_start.mon || rules[ri].dlt_end.mon)
 863         {
 864           guint rulespan = (rules[ri + 1].start_year - rules[ri].start_year);
 865           guint transitions = rules[ri].dlt_start.mon > 0 ? 1 : 0;
 866           transitions += rules[ri].dlt_end.mon > 0 ? 1 : 0;
 867           type_count += rules[ri].dlt_start.mon > 0 ? 2 : 1;
 868           trans_count += transitions * rulespan;
 869         }
 870       else
 871         type_count++;
 872     }
 873
 874   gtz->t_info = g_array_sized_new (FALSE, TRUE, sizeof (TransitionInfo), type_count);
 875   gtz->transitions = g_array_sized_new (FALSE, TRUE, sizeof (Transition), trans_count);
 876
 877   last_offset = rules[0].std_offset;
 878
 879   for (ri = 0; ri < rules_num - 1; ri++)
 880     {
 881       if ((rules[ri].std_offset || rules[ri].dlt_offset) &&
 882           rules[ri].dlt_start.mon == 0 && rules[ri].dlt_end.mon == 0)
 883         {
 884           TransitionInfo std_info;
 885           /* Standard */
 886           fill_transition_info_from_rule (&std_info, &(rules[ri]), FALSE);
 887           g_array_append_val (gtz->t_info, std_info);
 888
 889           if (ri > 0 &&
 890               ((rules[ri - 1].dlt_start.mon > 12 &&
 891                 rules[ri - 1].dlt_start.wday > rules[ri - 1].dlt_end.wday) ||
 892                 rules[ri - 1].dlt_start.mon > rules[ri - 1].dlt_end.mon))
 893             {
 894               /* The previous rule was a southern hemisphere rule that
 895                  starts the year with DST, so we need to add a
 896                  transition to return to standard time */
 897               guint year = rules[ri].start_year;
 898               gint64 std_time =  boundary_for_year (&rules[ri].dlt_end,
 899                                                     year, last_offset);
 900               Transition std_trans = {std_time, info_index};
 901               g_array_append_val (gtz->transitions, std_trans);
 902
 903             }
 904           last_offset = rules[ri].std_offset;
 905           ++info_index;
 906           skip_first_std_trans = TRUE;
 907          }
 908       else if (rules[ri].std_offset || rules[ri].dlt_offset)
 909         {
 910           const guint start_year = rules[ri].start_year;
 911           const guint end_year = rules[ri + 1].start_year;
 912           gboolean dlt_first;
 913           guint year;
 914           TransitionInfo std_info, dlt_info;
 915           if (rules[ri].dlt_start.mon > 12)
 916             dlt_first = rules[ri].dlt_start.wday > rules[ri].dlt_end.wday;
 917           else
 918             dlt_first = rules[ri].dlt_start.mon > rules[ri].dlt_end.mon;
 919           /* Standard rules are always even, because before the first
 920              transition is always standard time, and 0 is even. */
 921           fill_transition_info_from_rule (&std_info, &(rules[ri]), FALSE);
 922           fill_transition_info_from_rule (&dlt_info, &(rules[ri]), TRUE);
 923
 924           g_array_append_val (gtz->t_info, std_info);
 925           g_array_append_val (gtz->t_info, dlt_info);
 926
 927           /* Transition dates. We hope that a year which ends daylight
 928              time in a southern-hemisphere country (i.e., one that
 929              begins the year in daylight time) will include a rule
 930              which has only a dlt_end. */
 931           for (year = start_year; year < end_year; year++)
 932             {
 933               gint32 dlt_offset = (dlt_first ? last_offset :
 934                                    rules[ri].dlt_offset);
 935               gint32 std_offset = (dlt_first ? rules[ri].std_offset :
 936                                    last_offset);
 937               /* NB: boundary_for_year returns 0 if mon == 0 */
 938               gint64 std_time =  boundary_for_year (&rules[ri].dlt_end,
 939                                                     year, dlt_offset);
 940               gint64 dlt_time = boundary_for_year (&rules[ri].dlt_start,
 941                                                    year, std_offset);
 942               Transition std_trans = {std_time, info_index};
 943               Transition dlt_trans = {dlt_time, info_index + 1};
 944               last_offset = (dlt_first ? rules[ri].dlt_offset :
 945                              rules[ri].std_offset);
 946               if (dlt_first)
 947                 {
 948                   if (skip_first_std_trans)
 949                     skip_first_std_trans = FALSE;
 950                   else if (std_time)
 951                     g_array_append_val (gtz->transitions, std_trans);
 952                   if (dlt_time)
 953                     g_array_append_val (gtz->transitions, dlt_trans);
 954                 }
 955               else
 956                 {
 957                   if (dlt_time)
 958                     g_array_append_val (gtz->transitions, dlt_trans);
 959                   if (std_time)
 960                     g_array_append_val (gtz->transitions, std_trans);
 961                 }
 962             }
 963
 964           info_index += 2;
 965         }
 966     }
 967   if (ri > 0 &&
 968       ((rules[ri - 1].dlt_start.mon > 12 &&
 969         rules[ri - 1].dlt_start.wday > rules[ri - 1].dlt_end.wday) ||
 970        rules[ri - 1].dlt_start.mon > rules[ri - 1].dlt_end.mon))
 971     {
 972       /* The previous rule was a southern hemisphere rule that
 973          starts the year with DST, so we need to add a
 974          transition to return to standard time */
 975       TransitionInfo info;
 976       guint year = rules[ri].start_year;
 977       Transition trans;
 978       fill_transition_info_from_rule (&info, &(rules[ri - 1]), FALSE);
 979       g_array_append_val (gtz->t_info, info);
 980       trans.time = boundary_for_year (&rules[ri - 1].dlt_end,
 981                                       year, last_offset);
 982       trans.info_index = info_index;
 983       g_array_append_val (gtz->transitions, trans);
 984      }
 985 }
 986
 987 /*
 988  * parses date[/time] for parsing TZ environment variable
 989  *
 990  * date is either Mm.w.d, Jn or N
 991  * - m is 1 to 12
 992  * - w is 1 to 5
 993  * - d is 0 to 6
 994  * - n is 1 to 365
 995  * - N is 0 to 365
 996  *
 997  * time is either h or hh[[:]mm[[[:]ss]]]
 998  *  - h[h] is 0 to 23
 999  *  - mm is 00 to 59
1000  *  - ss is 00 to 59
1001  */
1002 static gboolean
1003 parse_mwd_boundary (gchar **pos, TimeZoneDate *boundary)
1004 {
1005   gint month, week, day;
1006
1007   if (**pos == '\0' || **pos < '0' || '9' < **pos)
1008     return FALSE;
1009
1010   month = *(*pos)++ - '0';
1011
1012   if ((month == 1 && **pos >= '0' && '2' >= **pos) ||
1013       (month == 0 && **pos >= '0' && '9' >= **pos))
1014     {
1015       month *= 10;
1016       month += *(*pos)++ - '0';
1017     }
1018
1019   if (*(*pos)++ != '.' || month == 0)
1020     return FALSE;
1021
1022   if (**pos == '\0' || **pos < '1' || '5' < **pos)
1023     return FALSE;
1024
1025   week = *(*pos)++ - '0';
1026
1027   if (*(*pos)++ != '.')
1028     return FALSE;
1029
1030   if (**pos == '\0' || **pos < '0' || '6' < **pos)
1031     return FALSE;
1032
1033   day = *(*pos)++ - '0';
1034
1035   if (!day)
1036     day += 7;
1037
1038   boundary->year = 0;
1039   boundary->mon = month;
1040   boundary->week = week;
1041   boundary->wday = day;
1042   return TRUE;
1043 }
1044
1045 /* Different implementations of tzset interpret the Julian day field
1046    differently. For example, Linux specifies that it should be 1-based
1047    (1 Jan is JD 1) for both Jn and n formats, while zOS and BSD
1048    specify that a Jn JD is 1-based while an n JD is 0-based. Rather
1049    than trying to follow different specs, we will follow GDate's
1050    practice thatIn order to keep it simple, we will follow Linux's
1051    practice. */
1052
1053 static gboolean
1054 parse_julian_boundary (gchar** pos, TimeZoneDate *boundary,
1055                        gboolean ignore_leap)
1056 {
1057   gint day = 0;
1058   GDate date;
1059
1060   while (**pos >= '0' && '9' >= **pos)
1061     {
1062       day *= 10;
1063       day += *(*pos)++ - '0';
1064     }
1065
1066   if (day < 1 || 365 < day)
1067     return FALSE;
1068
1069   g_date_clear (&date, 1);
1070   g_date_set_julian (&date, day);
1071   boundary->year = 0;
1072   boundary->mon = (int) g_date_get_month (&date);
1073   boundary->mday = (int) g_date_get_day (&date);
1074   boundary->wday = 0;
1075
1076   if (!ignore_leap && day >= 59)
1077     boundary->mday++;
1078
1079   return TRUE;
1080 }
1081
1082 static gboolean
1083 parse_tz_boundary (const gchar  *identifier,
1084                    TimeZoneDate *boundary)
1085 {
1086   gchar *pos;
1087
1088   pos = (gchar*)identifier;
1089   /* Month-week-weekday */
1090   if (*pos == 'M')
1091     {
1092       ++pos;
1093       if (!parse_mwd_boundary (&pos, boundary))
1094         return FALSE;
1095     }
1096   /* Julian date which ignores Feb 29 in leap years */
1097   else if (*pos == 'J')
1098     {
1099       ++pos;
1100       if (!parse_julian_boundary (&pos, boundary, FALSE))
1101         return FALSE ;
1102     }
1103   /* Julian date which counts Feb 29 in leap years */
1104   else if (*pos >= '0' && '9' >= *pos)
1105     {
1106       if (!parse_julian_boundary (&pos, boundary, TRUE))
1107         return FALSE;
1108     }
1109   else
1110     return FALSE;
1111
1112   /* Time */
1113
1114   if (*pos == '/')
1115     {
1116       gint32 offset;
1117
1118       if (!parse_time (++pos, &offset))
1119         return FALSE;
1120
1121       boundary->hour = offset / 3600;
1122       boundary->min = (offset / 60) % 60;
1123       boundary->sec = offset % 3600;
1124
1125       return TRUE;
1126     }
1127
1128   else
1129     {
1130       boundary->hour = 2;
1131       boundary->min = 0;
1132       boundary->sec = 0;
1133
1134       return *pos == '\0';
1135     }
1136 }
1137
1138 static gint
1139 create_ruleset_from_rule (TimeZoneRule **rules, TimeZoneRule *rule)
1140 {
1141   *rules = g_new0 (TimeZoneRule, 2);
1142
1143   (*rules)[0].start_year = MIN_TZYEAR;
1144   (*rules)[1].start_year = MAX_TZYEAR;
1145
1146   (*rules)[0].std_offset = -rule->std_offset;
1147   (*rules)[0].dlt_offset = -rule->dlt_offset;
1148   (*rules)[0].dlt_start  = rule->dlt_start;
1149   (*rules)[0].dlt_end = rule->dlt_end;
1150   strcpy ((*rules)[0].std_name, rule->std_name);
1151   strcpy ((*rules)[0].dlt_name, rule->dlt_name);
1152   return 2;
1153 }
1154
1155 static gboolean
1156 parse_offset (gchar **pos, gint32 *target)
1157 {
1158   gchar *buffer;
1159   gchar *target_pos = *pos;
1160   gboolean ret;
1161
1162   while (**pos == '+' || **pos == '-' || **pos == ':' ||
1163          (**pos >= '0' && '9' >= **pos))
1164     ++(*pos);
1165
1166   buffer = g_strndup (target_pos, *pos - target_pos);
1167   ret = parse_constant_offset (buffer, target);
1168   g_free (buffer);
1169
1170   return ret;
1171 }
1172
1173 static gboolean
1174 parse_identifier_boundary (gchar **pos, TimeZoneDate *target)
1175 {
1176   gchar *buffer;
1177   gchar *target_pos = *pos;
1178   gboolean ret;
1179
1180   while (**pos != ',' && **pos != '\0')
1181     ++(*pos);
1182   buffer = g_strndup (target_pos, *pos - target_pos);
1183   ret = parse_tz_boundary (buffer, target);
1184   g_free (buffer);
1185
1186   return ret;
1187 }
1188
1189 static gboolean
1190 set_tz_name (gchar **pos, gchar *buffer, guint size)
1191 {
1192   gchar *name_pos = *pos;
1193   guint len;
1194
1195   /* Name is ASCII alpha (Is this necessarily true?) */
1196   while (g_ascii_isalpha (**pos))
1197     ++(*pos);
1198
1199   /* Name should be three or more alphabetic characters */
1200   if (*pos - name_pos < 3)
1201     return FALSE;
1202
1203   memset (buffer, 0, NAME_SIZE);
1204   /* name_pos isn't 0-terminated, so we have to limit the length expressly */
1205   len = *pos - name_pos > size - 1 ? size - 1 : *pos - name_pos;
1206   strncpy (buffer, name_pos, len);
1207   return TRUE;
1208 }
1209
1210 static gboolean
1211 parse_identifier_boundaries (gchar **pos, TimeZoneRule *tzr)
1212 {
1213   if (*(*pos)++ != ',')
1214     return FALSE;
1215
1216   /* Start date */
1217   if (!parse_identifier_boundary (pos, &(tzr->dlt_start)) || *(*pos)++ != ',')
1218     return FALSE;
1219
1220   /* End date */
1221   if (!parse_identifier_boundary (pos, &(tzr->dlt_end)))
1222     return FALSE;
1223   return TRUE;
1224 }
1225
1226 /*
1227  * Creates an array of TimeZoneRule from a TZ environment variable
1228  * type of identifier.  Should free rules afterwards
1229  */
1230 static gint
1231 rules_from_identifier (const gchar   *identifier,
1232                        TimeZoneRule **rules)
1233 {
1234   gchar *pos;
1235   TimeZoneRule tzr;
1236
1237   if (!identifier)
1238     return 0;
1239
1240   pos = (gchar*)identifier;
1241   memset (&tzr, 0, sizeof (tzr));
1242   /* Standard offset */
1243   if (!(set_tz_name (&pos, tzr.std_name, NAME_SIZE)) ||
1244       !parse_offset (&pos, &(tzr.std_offset)))
1245     return 0;
1246
1247   if (*pos == 0)
1248     return create_ruleset_from_rule (rules, &tzr);
1249
1250   /* Format 2 */
1251   if (!(set_tz_name (&pos, tzr.dlt_name, NAME_SIZE)))
1252     return 0;
1253   parse_offset (&pos, &(tzr.dlt_offset));
1254   if (tzr.dlt_offset == 0) /* No daylight offset given, assume it's 1
1255                               hour earlier that standard */
1256     tzr.dlt_offset = tzr.std_offset - 3600;
1257   if (*pos == '\0')
1258 #ifdef G_OS_WIN32
1259     /* Windows allows us to use the US DST boundaries if they're not given */
1260     {
1261       int i;
1262       guint rules_num = 0;
1263
1264       /* Use US rules, Windows' default is Pacific Standard Time */
1265       if ((rules_num = rules_from_windows_time_zone ("Pacific Standard Time",
1266                                                      rules)))
1267         {
1268           for (i = 0; i < rules_num - 1; i++)
1269             {
1270               (*rules)[i].std_offset = - tzr.std_offset;
1271               (*rules)[i].dlt_offset = - tzr.dlt_offset;
1272               strcpy ((*rules)[i].std_name, tzr.std_name);
1273               strcpy ((*rules)[i].dlt_name, tzr.dlt_name);
1274             }
1275
1276           return rules_num;
1277         }
1278       else
1279         return 0;
1280     }
1281 #else
1282   return 0;
1283 #endif
1284   /* Start and end required (format 2) */
1285   if (!parse_identifier_boundaries (&pos, &tzr))
1286     return 0;
1287
1288   return create_ruleset_from_rule (rules, &tzr);
1289 }
1290
1291 /* Construction {{{1 */
1292 /**
1293  * g_time_zone_new:
1294  * @identifier: (allow-none): a timezone identifier
1295  *
1296  * Creates a #GTimeZone corresponding to @identifier.
1297  *
1298  * @identifier can either be an RFC3339/ISO 8601 time offset or
1299  * something that would pass as a valid value for the
1300  * <varname>TZ</varname> environment variable (including %NULL).
1301  *
1302  * In Windows, @identifier can also be the unlocalized name of a time
1303  * zone for standard time, for example "Pacific Standard Time".
1304  *
1305  * Valid RFC3339 time offsets are <literal>"Z"</literal> (for UTC) or
1306  * <literal>"±hh:mm"</literal>.  ISO 8601 additionally specifies
1307  * <literal>"±hhmm"</literal> and <literal>"±hh"</literal>.  Offsets are
1308  * time values to be added to Coordinated Universal Time (UTC) to get
1309  * the local time.
1310  *
1311  * In Unix, the <varname>TZ</varname> environment variable typically
1312  * corresponds to the name of a file in the zoneinfo database, or
1313  * string in "std offset [dst [offset],start[/time],end[/time]]"
1314  * (POSIX) format.  There  are  no spaces in the specification.  The
1315  * name of standard and daylight savings time zone must be three or more
1316  * alphabetic characters.  Offsets are time values to be added to local
1317  * time to get Coordinated Universal Time (UTC) and should be
1318  * <literal>"[±]hh[[:]mm[:ss]]"</literal>.  Dates are either
1319  * <literal>"Jn"</literal> (Julian day with n between 1 and 365, leap
1320  * years not counted), <literal>"n"</literal> (zero-based Julian day
1321  * with n between 0 and 365) or <literal>"Mm.w.d"</literal> (day d
1322  * (0 <= d <= 6) of week w (1 <= w <= 5) of month m (1 <= m <= 12), day
1323  * 0 is a Sunday).  Times are in local wall clock time, the default is
1324  * 02:00:00.
1325  *
1326  * In Windows, the "tzn[+|–]hh[:mm[:ss]][dzn]" format is used, but also
1327  * accepts POSIX format.  The Windows format uses US rules for all time
1328  * zones; daylight savings time is 60 minutes behind the standard time
1329  * with date and time of change taken from Pacific Standard Time.
1330  * Offsets are time values to be added to the local time to get
1331  * Coordinated Universal Time (UTC).
1332  *
1333  * g_time_zone_new_local() calls this function with the value of the
1334  * <varname>TZ</varname> environment variable.  This function itself is
1335  * independent of the value of <varname>TZ</varname>, but if @identifier
1336  * is %NULL then <filename>/etc/localtime</filename> will be consulted
1337  * to discover the correct time zone on Unix and the registry will be
1338  * consulted or GetTimeZoneInformation() will be used to get the local
1339  * time zone on Windows.
1340  *
1341  * If intervals are not available, only time zone rules from
1342  * <varname>TZ</varname> environment variable or other means, then they
1343  * will be computed from year 1900 to 2037.  If the maximum year for the
1344  * rules is available and it is greater than 2037, then it will followed
1345  * instead.
1346  *
1347  * See <ulink
1348  * url='http://tools.ietf.org/html/rfc3339#section-5.6'>RFC3339
1349  * §5.6</ulink> for a precise definition of valid RFC3339 time offsets
1350  * (the <varname>time-offset</varname> expansion) and ISO 8601 for the
1351  * full list of valid time offsets.  See <ulink
1352  * url='http://www.gnu.org/s/libc/manual/html_node/TZ-Variable.html'>The
1353  * GNU C Library manual</ulink> for an explanation of the possible
1354  * values of the <varname>TZ</varname> environment variable.  See <ulink
1355  * url='http://msdn.microsoft.com/en-us/library/ms912391%28v=winembedded.11%29.aspx'>
1356  * Microsoft Time Zone Index Values</ulink> for the list of time zones
1357  * on Windows.
1358  *
1359  * You should release the return value by calling g_time_zone_unref()
1360  * when you are done with it.
1361  *
1362  * Returns: the requested timezone
1363  *
1364  * Since: 2.26
1365  **/
1366 GTimeZone *
1367 g_time_zone_new (const gchar *identifier)
1368 {
1369   GTimeZone *tz = NULL;
1370   TimeZoneRule *rules;
1371   gint rules_num;
1372
1373   G_LOCK (time_zones);
1374   if (time_zones == NULL)
1375     time_zones = g_hash_table_new (g_str_hash, g_str_equal);
1376
1377   if (identifier)
1378     {
1379       tz = g_hash_table_lookup (time_zones, identifier);
1380       if (tz)
1381         {
1382           g_atomic_int_inc (&tz->ref_count);
1383           G_UNLOCK (time_zones);
1384           return tz;
1385         }
1386     }
1387
1388   tz = g_slice_new0 (GTimeZone);
1389   tz->name = g_strdup (identifier);
1390   tz->ref_count = 0;
1391
1392   zone_for_constant_offset (tz, identifier);
1393
1394   if (tz->t_info == NULL &&
1395       (rules_num = rules_from_identifier (identifier, &rules)))
1396     {
1397       init_zone_from_rules (tz, rules, rules_num);
1398       g_free (rules);
1399     }
1400
1401   if (tz->t_info == NULL)
1402     {
1403 #ifdef G_OS_UNIX
1404       GBytes *zoneinfo = zone_info_unix (identifier);
1405       if (!zoneinfo)
1406         zone_for_constant_offset (tz, "UTC");
1407       else
1408         {
1409           init_zone_from_iana_info (tz, zoneinfo);
1410           g_bytes_unref (zoneinfo);
1411         }
1412 #elif defined (G_OS_WIN32)
1413       if ((rules_num = rules_from_windows_time_zone (identifier, &rules)))
1414         {
1415           init_zone_from_rules (tz, rules, rules_num);
1416           g_free (rules);
1417         }
1418     }
1419
1420   if (tz->t_info == NULL)
1421     {
1422       if (identifier)
1423         zone_for_constant_offset (tz, "UTC");
1424       else
1425         {
1426           TIME_ZONE_INFORMATION tzi;
1427
1428           if (GetTimeZoneInformation (&tzi) != TIME_ZONE_ID_INVALID)
1429             {
1430               rules = g_new0 (TimeZoneRule, 2);
1431
1432               rule_from_windows_time_zone_info (&rules[0], &tzi);
1433
1434               memset (rules[0].std_name, 0, NAME_SIZE);
1435               memset (rules[0].dlt_name, 0, NAME_SIZE);
1436
1437               rules[0].start_year = MIN_TZYEAR;
1438               rules[1].start_year = MAX_TZYEAR;
1439
1440               init_zone_from_rules (tz, rules, 2);
1441
1442               g_free (rules);
1443             }
1444         }
1445 #endif
1446     }
1447
1448   if (tz->t_info != NULL)
1449     {
1450       if (identifier)
1451         g_hash_table_insert (time_zones, tz->name, tz);
1452     }
1453   g_atomic_int_inc (&tz->ref_count);
1454   G_UNLOCK (time_zones);
1455
1456   return tz;
1457 }
1458
1459 /**
1460  * g_time_zone_new_utc:
1461  *
1462  * Creates a #GTimeZone corresponding to UTC.
1463  *
1464  * This is equivalent to calling g_time_zone_new() with a value like
1465  * "Z", "UTC", "+00", etc.
1466  *
1467  * You should release the return value by calling g_time_zone_unref()
1468  * when you are done with it.
1469  *
1470  * Returns: the universal timezone
1471  *
1472  * Since: 2.26
1473  **/
1474 GTimeZone *
1475 g_time_zone_new_utc (void)
1476 {
1477   return g_time_zone_new ("UTC");
1478 }
1479
1480 /**
1481  * g_time_zone_new_local:
1482  *
1483  * Creates a #GTimeZone corresponding to local time.  The local time
1484  * zone may change between invocations to this function; for example,
1485  * if the system administrator changes it.
1486  *
1487  * This is equivalent to calling g_time_zone_new() with the value of the
1488  * <varname>TZ</varname> environment variable (including the possibility
1489  * of %NULL).
1490  *
1491  * You should release the return value by calling g_time_zone_unref()
1492  * when you are done with it.
1493  *
1494  * Returns: the local timezone
1495  *
1496  * Since: 2.26
1497  **/
1498 GTimeZone *
1499 g_time_zone_new_local (void)
1500 {
1501   return g_time_zone_new (getenv ("TZ"));
1502 }
1503
1504 #define TRANSITION(n)         g_array_index (tz->transitions, Transition, n)
1505 #define TRANSITION_INFO(n)    g_array_index (tz->t_info, TransitionInfo, n)
1506
1507 /* Internal helpers {{{1 */
1508 /* NB: Interval 0 is before the first transition, so there's no
1509  * transition structure to point to which TransitionInfo to
1510  * use. Rule-based zones are set up so that TI 0 is always standard
1511  * time (which is what's in effect before Daylight time got started
1512  * in the early 20th century), but IANA tzfiles don't follow that
1513  * convention. The tzfile documentation says to use the first
1514  * standard-time (i.e., non-DST) tinfo, so that's what we do.
1515  */
1516 inline static const TransitionInfo*
1517 interval_info (GTimeZone *tz,
1518                guint      interval)
1519 {
1520   guint index;
1521   g_return_val_if_fail (tz->t_info != NULL, NULL);
1522   if (interval && tz->transitions && interval <= tz->transitions->len)
1523     index = (TRANSITION(interval - 1)).info_index;
1524   else
1525     {
1526       for (index = 0; index < tz->t_info->len; index++)
1527         {
1528           TransitionInfo *tzinfo = &(TRANSITION_INFO(index));
1529           if (!tzinfo->is_dst)
1530             return tzinfo;
1531         }
1532       index = 0;
1533     }
1534
1535   return &(TRANSITION_INFO(index));
1536 }
1537
1538 inline static gint64
1539 interval_start (GTimeZone *tz,
1540                 guint      interval)
1541 {
1542   if (!interval || tz->transitions == NULL || tz->transitions->len == 0)
1543     return G_MININT64;
1544   if (interval > tz->transitions->len)
1545     interval = tz->transitions->len;
1546   return (TRANSITION(interval - 1)).time;
1547 }
1548
1549 inline static gint64
1550 interval_end (GTimeZone *tz,
1551               guint      interval)
1552 {
1553   if (tz->transitions && interval < tz->transitions->len)
1554     return (TRANSITION(interval)).time - 1;
1555   return G_MAXINT64;
1556 }
1557
1558 inline static gint32
1559 interval_offset (GTimeZone *tz,
1560                  guint      interval)
1561 {
1562   g_return_val_if_fail (tz->t_info != NULL, 0);
1563   return interval_info (tz, interval)->gmt_offset;
1564 }
1565
1566 inline static gboolean
1567 interval_isdst (GTimeZone *tz,
1568                 guint      interval)
1569 {
1570   g_return_val_if_fail (tz->t_info != NULL, 0);
1571   return interval_info (tz, interval)->is_dst;
1572 }
1573
1574
1575 inline static gboolean
1576 interval_isgmt (GTimeZone *tz,
1577                 guint      interval)
1578 {
1579   g_return_val_if_fail (tz->t_info != NULL, 0);
1580   return interval_info (tz, interval)->is_gmt;
1581 }
1582
1583 inline static gboolean
1584 interval_isstandard (GTimeZone *tz,
1585                 guint      interval)
1586 {
1587   return interval_info (tz, interval)->is_standard;
1588 }
1589
1590 inline static gchar*
1591 interval_abbrev (GTimeZone *tz,
1592                   guint      interval)
1593 {
1594   g_return_val_if_fail (tz->t_info != NULL, 0);
1595   return interval_info (tz, interval)->abbrev;
1596 }
1597
1598 inline static gint64
1599 interval_local_start (GTimeZone *tz,
1600                       guint      interval)
1601 {
1602   if (interval)
1603     return interval_start (tz, interval) + interval_offset (tz, interval);
1604
1605   return G_MININT64;
1606 }
1607
1608 inline static gint64
1609 interval_local_end (GTimeZone *tz,
1610                     guint      interval)
1611 {
1612   if (tz->transitions && interval < tz->transitions->len)
1613     return interval_end (tz, interval) + interval_offset (tz, interval);
1614
1615   return G_MAXINT64;
1616 }
1617
1618 static gboolean
1619 interval_valid (GTimeZone *tz,
1620                 guint      interval)
1621 {
1622   if ( tz->transitions == NULL)
1623     return interval == 0;
1624   return interval <= tz->transitions->len;
1625 }
1626
1627 /* g_time_zone_find_interval() {{{1 */
1628
1629 /**
1630  * g_time_zone_adjust_time:
1631  * @tz: a #GTimeZone
1632  * @type: the #GTimeType of @time_
1633  * @time_: a pointer to a number of seconds since January 1, 1970
1634  *
1635  * Finds an interval within @tz that corresponds to the given @time_,
1636  * possibly adjusting @time_ if required to fit into an interval.
1637  * The meaning of @time_ depends on @type.
1638  *
1639  * This function is similar to g_time_zone_find_interval(), with the
1640  * difference that it always succeeds (by making the adjustments
1641  * described below).
1642  *
1643  * In any of the cases where g_time_zone_find_interval() succeeds then
1644  * this function returns the same value, without modifying @time_.
1645  *
1646  * This function may, however, modify @time_ in order to deal with
1647  * non-existent times.  If the non-existent local @time_ of 02:30 were
1648  * requested on March 14th 2010 in Toronto then this function would
1649  * adjust @time_ to be 03:00 and return the interval containing the
1650  * adjusted time.
1651  *
1652  * Returns: the interval containing @time_, never -1
1653  *
1654  * Since: 2.26
1655  **/
1656 gint
1657 g_time_zone_adjust_time (GTimeZone *tz,
1658                          GTimeType  type,
1659                          gint64    *time_)
1660 {
1661   gint i;
1662   guint intervals;
1663
1664   if (tz->transitions == NULL)
1665     return 0;
1666
1667   intervals = tz->transitions->len;
1668
1669   /* find the interval containing *time UTC
1670    * TODO: this could be binary searched (or better) */
1671   for (i = 0; i <= intervals; i++)
1672     if (*time_ <= interval_end (tz, i))
1673       break;
1674
1675   g_assert (interval_start (tz, i) <= *time_ && *time_ <= interval_end (tz, i));
1676
1677   if (type != G_TIME_TYPE_UNIVERSAL)
1678     {
1679       if (*time_ < interval_local_start (tz, i))
1680         /* if time came before the start of this interval... */
1681         {
1682           i--;
1683
1684           /* if it's not in the previous interval... */
1685           if (*time_ > interval_local_end (tz, i))
1686             {
1687               /* it doesn't exist.  fast-forward it. */
1688               i++;
1689               *time_ = interval_local_start (tz, i);
1690             }
1691         }
1692
1693       else if (*time_ > interval_local_end (tz, i))
1694         /* if time came after the end of this interval... */
1695         {
1696           i++;
1697
1698           /* if it's not in the next interval... */
1699           if (*time_ < interval_local_start (tz, i))
1700             /* it doesn't exist.  fast-forward it. */
1701             *time_ = interval_local_start (tz, i);
1702         }
1703
1704       else if (interval_isdst (tz, i) != type)
1705         /* it's in this interval, but dst flag doesn't match.
1706          * check neighbours for a better fit. */
1707         {
1708           if (i && *time_ <= interval_local_end (tz, i - 1))
1709             i--;
1710
1711           else if (i < intervals &&
1712                    *time_ >= interval_local_start (tz, i + 1))
1713             i++;
1714         }
1715     }
1716
1717   return i;
1718 }
1719
1720 /**
1721  * g_time_zone_find_interval:
1722  * @tz: a #GTimeZone
1723  * @type: the #GTimeType of @time_
1724  * @time_: a number of seconds since January 1, 1970
1725  *
1726  * Finds an the interval within @tz that corresponds to the given @time_.
1727  * The meaning of @time_ depends on @type.
1728  *
1729  * If @type is %G_TIME_TYPE_UNIVERSAL then this function will always
1730  * succeed (since universal time is monotonic and continuous).
1731  *
1732  * Otherwise @time_ is treated is local time.  The distinction between
1733  * %G_TIME_TYPE_STANDARD and %G_TIME_TYPE_DAYLIGHT is ignored except in
1734  * the case that the given @time_ is ambiguous.  In Toronto, for example,
1735  * 01:30 on November 7th 2010 occurred twice (once inside of daylight
1736  * savings time and the next, an hour later, outside of daylight savings
1737  * time).  In this case, the different value of @type would result in a
1738  * different interval being returned.
1739  *
1740  * It is still possible for this function to fail.  In Toronto, for
1741  * example, 02:00 on March 14th 2010 does not exist (due to the leap
1742  * forward to begin daylight savings time).  -1 is returned in that
1743  * case.
1744  *
1745  * Returns: the interval containing @time_, or -1 in case of failure
1746  *
1747  * Since: 2.26
1748  */
1749 gint
1750 g_time_zone_find_interval (GTimeZone *tz,
1751                            GTimeType  type,
1752                            gint64     time_)
1753 {
1754   gint i;
1755   guint intervals;
1756
1757   if (tz->transitions == NULL)
1758     return 0;
1759   intervals = tz->transitions->len;
1760   for (i = 0; i <= intervals; i++)
1761     if (time_ <= interval_end (tz, i))
1762       break;
1763
1764   if (type == G_TIME_TYPE_UNIVERSAL)
1765     return i;
1766
1767   if (time_ < interval_local_start (tz, i))
1768     {
1769       if (time_ > interval_local_end (tz, --i))
1770         return -1;
1771     }
1772
1773   else if (time_ > interval_local_end (tz, i))
1774     {
1775       if (time_ < interval_local_start (tz, ++i))
1776         return -1;
1777     }
1778
1779   else if (interval_isdst (tz, i) != type)
1780     {
1781       if (i && time_ <= interval_local_end (tz, i - 1))
1782         i--;
1783
1784       else if (i < intervals && time_ >= interval_local_start (tz, i + 1))
1785         i++;
1786     }
1787
1788   return i;
1789 }
1790
1791 /* Public API accessors {{{1 */
1792
1793 /**
1794  * g_time_zone_get_abbreviation:
1795  * @tz: a #GTimeZone
1796  * @interval: an interval within the timezone
1797  *
1798  * Determines the time zone abbreviation to be used during a particular
1799  * @interval of time in the time zone @tz.
1800  *
1801  * For example, in Toronto this is currently "EST" during the winter
1802  * months and "EDT" during the summer months when daylight savings time
1803  * is in effect.
1804  *
1805  * Returns: the time zone abbreviation, which belongs to @tz
1806  *
1807  * Since: 2.26
1808  **/
1809 const gchar *
1810 g_time_zone_get_abbreviation (GTimeZone *tz,
1811                               gint       interval)
1812 {
1813   g_return_val_if_fail (interval_valid (tz, (guint)interval), NULL);
1814
1815   return interval_abbrev (tz, (guint)interval);
1816 }
1817
1818 /**
1819  * g_time_zone_get_offset:
1820  * @tz: a #GTimeZone
1821  * @interval: an interval within the timezone
1822  *
1823  * Determines the offset to UTC in effect during a particular @interval
1824  * of time in the time zone @tz.
1825  *
1826  * The offset is the number of seconds that you add to UTC time to
1827  * arrive at local time for @tz (ie: negative numbers for time zones
1828  * west of GMT, positive numbers for east).
1829  *
1830  * Returns: the number of seconds that should be added to UTC to get the
1831  *          local time in @tz
1832  *
1833  * Since: 2.26
1834  **/
1835 gint32
1836 g_time_zone_get_offset (GTimeZone *tz,
1837                         gint       interval)
1838 {
1839   g_return_val_if_fail (interval_valid (tz, (guint)interval), 0);
1840
1841   return interval_offset (tz, (guint)interval);
1842 }
1843
1844 /**
1845  * g_time_zone_is_dst:
1846  * @tz: a #GTimeZone
1847  * @interval: an interval within the timezone
1848  *
1849  * Determines if daylight savings time is in effect during a particular
1850  * @interval of time in the time zone @tz.
1851  *
1852  * Returns: %TRUE if daylight savings time is in effect
1853  *
1854  * Since: 2.26
1855  **/
1856 gboolean
1857 g_time_zone_is_dst (GTimeZone *tz,
1858                     gint       interval)
1859 {
1860   g_return_val_if_fail (interval_valid (tz, interval), FALSE);
1861
1862   if (tz->transitions == NULL)
1863     return FALSE;
1864
1865   return interval_isdst (tz, (guint)interval);
1866 }
1867
1868 /* Epilogue {{{1 */
1869 /* vim:set foldmethod=marker: */