time/tzset.c

   1 /* Copyright (C) 1991-2002,2003,2004,2007,2009 Free Software Foundation, Inc.
   2    This file is part of the GNU C Library.
   3
   4    The GNU C 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.1 of the License, or (at your option) any later version.
   8
   9    The GNU C 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 the GNU C Library; if not, see
  16    <http://www.gnu.org/licenses/>.  */
  17
  18 #include <ctype.h>
  19 #include <errno.h>
  20 #include <bits/libc-lock.h>
  21 #include <stddef.h>
  22 #include <stdio.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <time.h>
  26
  27
  28 #define NOID
  29 #include <timezone/tzfile.h>
  30
  31 char *__tzname[2] = { (char *) "GMT", (char *) "GMT" };
  32 int __daylight = 0;
  33 long int __timezone = 0L;
  34
  35 weak_alias (__tzname, tzname)
  36 weak_alias (__daylight, daylight)
  37 weak_alias (__timezone, timezone)
  38
  39 /* This locks all the state variables in tzfile.c and this file.  */
  40 __libc_lock_define_initialized (static, tzset_lock)
  41
  42
  43 #define min(a, b)       ((a) < (b) ? (a) : (b))
  44 #define max(a, b)       ((a) > (b) ? (a) : (b))
  45 #define sign(x)         ((x) < 0 ? -1 : 1)
  46
  47
  48 /* This structure contains all the information about a
  49    timezone given in the POSIX standard TZ envariable.  */
  50 typedef struct
  51   {
  52     const char *name;
  53
  54     /* When to change.  */
  55     enum { J0, J1, M } type;    /* Interpretation of:  */
  56     unsigned short int m, n, d; /* Month, week, day.  */
  57     unsigned int secs;          /* Time of day.  */
  58
  59     long int offset;            /* Seconds east of GMT (west if < 0).  */
  60
  61     /* We cache the computed time of change for a
  62        given year so we don't have to recompute it.  */
  63     time_t change;      /* When to change to this zone.  */
  64     int computed_for;   /* Year above is computed for.  */
  65   } tz_rule;
  66
  67 /* tz_rules[0] is standard, tz_rules[1] is daylight.  */
  68 static tz_rule tz_rules[2];
  69
  70
  71 static void compute_change (tz_rule *rule, int year) __THROW internal_function;
  72 static void tzset_internal (int always, int explicit)
  73      __THROW internal_function;
  74 \f
  75 /* List of buffers containing time zone strings. */
  76 struct tzstring_l
  77 {
  78   struct tzstring_l *next;
  79   size_t len;  /* strlen(data) - doesn't count terminating NUL! */
  80   char data[0];
  81 };
  82
  83 static struct tzstring_l *tzstring_list;
  84
  85 /* Allocate a permanent home for S.  It will never be moved or deallocated,
  86    but may share space with other strings.
  87    Don't modify the returned string. */
  88 char *
  89 __tzstring (const char *s)
  90 {
  91   char *p;
  92   struct tzstring_l *t, *u, *new;
  93   size_t len = strlen (s);
  94
  95   /* Walk the list and look for a match.  If this string is the same
  96      as the end of an already-allocated string, it can share space. */
  97   for (u = t = tzstring_list; t; u = t, t = t->next)
  98     if (len <= t->len)
  99       {
 100         p = &t->data[t->len - len];
 101         if (strcmp (s, p) == 0)
 102           return p;
 103       }
 104
 105   /* Not found; allocate a new buffer. */
 106   new = malloc (sizeof (struct tzstring_l) + len + 1);
 107   if (!new)
 108     return NULL;
 109
 110   new->next = NULL;
 111   new->len = len;
 112   strcpy (new->data, s);
 113
 114   if (u)
 115     u->next = new;
 116   else
 117     tzstring_list = new;
 118
 119   return new->data;
 120 }
 121 \f
 122 /* Maximum length of a timezone name.  tzset_internal keeps this up to date
 123    (never decreasing it) when ! __use_tzfile.
 124    tzfile.c keeps it up to date when __use_tzfile.  */
 125 size_t __tzname_cur_max;
 126
 127 long int
 128 __tzname_max ()
 129 {
 130   __libc_lock_lock (tzset_lock);
 131
 132   tzset_internal (0, 0);
 133
 134   __libc_lock_unlock (tzset_lock);
 135
 136   return __tzname_cur_max;
 137 }
 138 \f
 139 static char *old_tz;
 140
 141 static void
 142 internal_function
 143 update_vars (void)
 144 {
 145   __daylight = tz_rules[0].offset != tz_rules[1].offset;
 146   __timezone = -tz_rules[0].offset;
 147   __tzname[0] = (char *) tz_rules[0].name;
 148   __tzname[1] = (char *) tz_rules[1].name;
 149
 150   /* Keep __tzname_cur_max up to date.  */
 151   size_t len0 = strlen (__tzname[0]);
 152   size_t len1 = strlen (__tzname[1]);
 153   if (len0 > __tzname_cur_max)
 154     __tzname_cur_max = len0;
 155   if (len1 > __tzname_cur_max)
 156     __tzname_cur_max = len1;
 157 }
 158
 159
 160 static unsigned int
 161 __attribute_noinline__
 162 compute_offset (unsigned int ss, unsigned int mm, unsigned int hh)
 163 {
 164   return min (ss, 59) + min (mm, 59) * 60 + min (hh, 24) * 60 * 60;
 165 }
 166
 167
 168 /* Parse the POSIX TZ-style string.  */
 169 void
 170 __tzset_parse_tz (tz)
 171      const char *tz;
 172 {
 173   unsigned short int hh, mm, ss;
 174
 175   /* Clear out old state and reset to unnamed UTC.  */
 176   memset (tz_rules, '\0', sizeof tz_rules);
 177   tz_rules[0].name = tz_rules[1].name = "";
 178
 179   /* Get the standard timezone name.  */
 180   char *tzbuf = strdupa (tz);
 181
 182   int consumed;
 183   if (sscanf (tz, "%[A-Za-z]%n", tzbuf, &consumed) != 1)
 184     {
 185       /* Check for the quoted version.  */
 186       char *wp = tzbuf;
 187       if (__builtin_expect (*tz++ != '<', 0))
 188         goto out;
 189
 190       while (isalnum (*tz) || *tz == '+' || *tz == '-')
 191         *wp++ = *tz++;
 192       if (__builtin_expect (*tz++ != '>' || wp - tzbuf < 3, 0))
 193         goto out;
 194       *wp = '\0';
 195     }
 196   else if (__builtin_expect (consumed < 3, 0))
 197     goto out;
 198   else
 199     tz += consumed;
 200
 201   tz_rules[0].name = __tzstring (tzbuf);
 202
 203   /* Figure out the standard offset from UTC.  */
 204   if (*tz == '\0' || (*tz != '+' && *tz != '-' && !isdigit (*tz)))
 205     goto out;
 206
 207   if (*tz == '-' || *tz == '+')
 208     tz_rules[0].offset = *tz++ == '-' ? 1L : -1L;
 209   else
 210     tz_rules[0].offset = -1L;
 211   switch (sscanf (tz, "%hu%n:%hu%n:%hu%n",
 212                   &hh, &consumed, &mm, &consumed, &ss, &consumed))
 213     {
 214     default:
 215       tz_rules[0].offset = 0;
 216       goto out;
 217     case 1:
 218       mm = 0;
 219     case 2:
 220       ss = 0;
 221     case 3:
 222       break;
 223     }
 224   tz_rules[0].offset *= compute_offset (ss, mm, hh);
 225   tz += consumed;
 226
 227   /* Get the DST timezone name (if any).  */
 228   if (*tz != '\0')
 229     {
 230       if (sscanf (tz, "%[A-Za-z]%n", tzbuf, &consumed) != 1)
 231         {
 232           /* Check for the quoted version.  */
 233           char *wp = tzbuf;
 234           const char *rp = tz;
 235           if (__builtin_expect (*rp++ != '<', 0))
 236             /* Punt on name, set up the offsets.  */
 237             goto done_names;
 238
 239           while (isalnum (*rp) || *rp == '+' || *rp == '-')
 240             *wp++ = *rp++;
 241           if (__builtin_expect (*rp++ != '>' || wp - tzbuf < 3, 0))
 242             /* Punt on name, set up the offsets.  */
 243             goto done_names;
 244           *wp = '\0';
 245           tz = rp;
 246         }
 247       else if (__builtin_expect (consumed < 3, 0))
 248         /* Punt on name, set up the offsets.  */
 249         goto done_names;
 250       else
 251         tz += consumed;
 252
 253       tz_rules[1].name = __tzstring (tzbuf);
 254
 255       /* Figure out the DST offset from GMT.  */
 256       if (*tz == '-' || *tz == '+')
 257         tz_rules[1].offset = *tz++ == '-' ? 1L : -1L;
 258       else
 259         tz_rules[1].offset = -1L;
 260
 261       switch (sscanf (tz, "%hu%n:%hu%n:%hu%n",
 262                       &hh, &consumed, &mm, &consumed, &ss, &consumed))
 263         {
 264         default:
 265           /* Default to one hour later than standard time.  */
 266           tz_rules[1].offset = tz_rules[0].offset + (60 * 60);
 267           break;
 268
 269         case 1:
 270           mm = 0;
 271         case 2:
 272           ss = 0;
 273         case 3:
 274           tz_rules[1].offset *= compute_offset (ss, mm, hh);
 275           tz += consumed;
 276           break;
 277         }
 278       if (*tz == '\0' || (tz[0] == ',' && tz[1] == '\0'))
 279         {
 280           /* There is no rule.  See if there is a default rule file.  */
 281           __tzfile_default (tz_rules[0].name, tz_rules[1].name,
 282                             tz_rules[0].offset, tz_rules[1].offset);
 283           if (__use_tzfile)
 284             {
 285               free (old_tz);
 286               old_tz = NULL;
 287               return;
 288             }
 289         }
 290     }
 291   else
 292     {
 293       /* There is no DST.  */
 294       tz_rules[1].name = tz_rules[0].name;
 295       tz_rules[1].offset = tz_rules[0].offset;
 296       goto out;
 297     }
 298
 299  done_names:
 300   /* Figure out the standard <-> DST rules.  */
 301   for (unsigned int whichrule = 0; whichrule < 2; ++whichrule)
 302     {
 303       register tz_rule *tzr = &tz_rules[whichrule];
 304
 305       /* Ignore comma to support string following the incorrect
 306          specification in early POSIX.1 printings.  */
 307       tz += *tz == ',';
 308
 309       /* Get the date of the change.  */
 310       if (*tz == 'J' || isdigit (*tz))
 311         {
 312           char *end;
 313           tzr->type = *tz == 'J' ? J1 : J0;
 314           if (tzr->type == J1 && !isdigit (*++tz))
 315             goto out;
 316           unsigned long int d = strtoul (tz, &end, 10);
 317           if (end == tz || d > 365)
 318             goto out;
 319           if (tzr->type == J1 && d == 0)
 320             goto out;
 321           tzr->d = d;
 322           tz = end;
 323         }
 324       else if (*tz == 'M')
 325         {
 326           tzr->type = M;
 327           if (sscanf (tz, "M%hu.%hu.%hu%n",
 328                       &tzr->m, &tzr->n, &tzr->d, &consumed) != 3
 329               || tzr->m < 1 || tzr->m > 12
 330               || tzr->n < 1 || tzr->n > 5 || tzr->d > 6)
 331             goto out;
 332           tz += consumed;
 333         }
 334       else if (*tz == '\0')
 335         {
 336           /* United States Federal Law, the equivalent of "M4.1.0,M10.5.0".  */
 337           tzr->type = M;
 338           if (tzr == &tz_rules[0])
 339             {
 340               tzr->m = 4;
 341               tzr->n = 1;
 342               tzr->d = 0;
 343             }
 344           else
 345             {
 346               tzr->m = 10;
 347               tzr->n = 5;
 348               tzr->d = 0;
 349             }
 350         }
 351       else
 352         goto out;
 353
 354       if (*tz != '\0' && *tz != '/' && *tz != ',')
 355         goto out;
 356       else if (*tz == '/')
 357         {
 358           /* Get the time of day of the change.  */
 359           ++tz;
 360           if (*tz == '\0')
 361             goto out;
 362           consumed = 0;
 363           switch (sscanf (tz, "%hu%n:%hu%n:%hu%n",
 364                           &hh, &consumed, &mm, &consumed, &ss, &consumed))
 365             {
 366             default:
 367               hh = 2;           /* Default to 2:00 AM.  */
 368             case 1:
 369               mm = 0;
 370             case 2:
 371               ss = 0;
 372             case 3:
 373               break;
 374             }
 375           tz += consumed;
 376           tzr->secs = (hh * 60 * 60) + (mm * 60) + ss;
 377         }
 378       else
 379         /* Default to 2:00 AM.  */
 380         tzr->secs = 2 * 60 * 60;
 381
 382       tzr->computed_for = -1;
 383     }
 384
 385  out:
 386   update_vars ();
 387 }
 388
 389 /* Interpret the TZ envariable.  */
 390 static void
 391 internal_function
 392 tzset_internal (always, explicit)
 393      int always;
 394      int explicit;
 395 {
 396   static int is_initialized;
 397   register const char *tz;
 398
 399   if (is_initialized && !always)
 400     return;
 401   is_initialized = 1;
 402
 403   /* Examine the TZ environment variable.  */
 404   tz = getenv ("TZ");
 405   if (tz == NULL && !explicit)
 406     /* Use the site-wide default.  This is a file name which means we
 407        would not see changes to the file if we compare only the file
 408        name for change.  We want to notice file changes if tzset() has
 409        been called explicitly.  Leave TZ as NULL in this case.  */
 410     tz = TZDEFAULT;
 411   if (tz && *tz == '\0')
 412     /* User specified the empty string; use UTC explicitly.  */
 413     tz = "Universal";
 414
 415   /* A leading colon means "implementation defined syntax".
 416      We ignore the colon and always use the same algorithm:
 417      try a data file, and if none exists parse the 1003.1 syntax.  */
 418   if (tz && *tz == ':')
 419     ++tz;
 420
 421   /* Check whether the value changed since the last run.  */
 422   if (old_tz != NULL && tz != NULL && strcmp (tz, old_tz) == 0)
 423     /* No change, simply return.  */
 424     return;
 425
 426   if (tz == NULL)
 427     /* No user specification; use the site-wide default.  */
 428     tz = TZDEFAULT;
 429
 430   tz_rules[0].name = NULL;
 431   tz_rules[1].name = NULL;
 432
 433   /* Save the value of `tz'.  */
 434   free (old_tz);
 435   old_tz = tz ? __strdup (tz) : NULL;
 436
 437   /* Try to read a data file.  */
 438   __tzfile_read (tz, 0, NULL);
 439   if (__use_tzfile)
 440     return;
 441
 442   /* No data file found.  Default to UTC if nothing specified.  */
 443
 444   if (tz == NULL || *tz == '\0'
 445       || (TZDEFAULT != NULL && strcmp (tz, TZDEFAULT) == 0))
 446     {
 447       memset (tz_rules, '\0', sizeof tz_rules);
 448       tz_rules[0].name = tz_rules[1].name = "UTC";
 449       if (J0 != 0)
 450         tz_rules[0].type = tz_rules[1].type = J0;
 451       tz_rules[0].change = tz_rules[1].change = (time_t) -1;
 452       update_vars ();
 453       return;
 454     }
 455
 456   __tzset_parse_tz (tz);
 457 }
 458 \f
 459 /* Figure out the exact time (as a time_t) in YEAR
 460    when the change described by RULE will occur and
 461    put it in RULE->change, saving YEAR in RULE->computed_for.  */
 462 static void
 463 internal_function
 464 compute_change (rule, year)
 465      tz_rule *rule;
 466      int year;
 467 {
 468   register time_t t;
 469
 470   if (year != -1 && rule->computed_for == year)
 471     /* Operations on times in 2 BC will be slower.  Oh well.  */
 472     return;
 473
 474   /* First set T to January 1st, 0:00:00 GMT in YEAR.  */
 475   if (year > 1970)
 476     t = ((year - 1970) * 365
 477          + /* Compute the number of leapdays between 1970 and YEAR
 478               (exclusive).  There is a leapday every 4th year ...  */
 479          + ((year - 1) / 4 - 1970 / 4)
 480          /* ... except every 100th year ... */
 481          - ((year - 1) / 100 - 1970 / 100)
 482          /* ... but still every 400th year.  */
 483          + ((year - 1) / 400 - 1970 / 400)) * SECSPERDAY;
 484   else
 485     t = 0;
 486
 487   switch (rule->type)
 488     {
 489     case J1:
 490       /* Jn - Julian day, 1 == January 1, 60 == March 1 even in leap years.
 491          In non-leap years, or if the day number is 59 or less, just
 492          add SECSPERDAY times the day number-1 to the time of
 493          January 1, midnight, to get the day.  */
 494       t += (rule->d - 1) * SECSPERDAY;
 495       if (rule->d >= 60 && __isleap (year))
 496         t += SECSPERDAY;
 497       break;
 498
 499     case J0:
 500       /* n - Day of year.
 501          Just add SECSPERDAY times the day number to the time of Jan 1st.  */
 502       t += rule->d * SECSPERDAY;
 503       break;
 504
 505     case M:
 506       /* Mm.n.d - Nth "Dth day" of month M.  */
 507       {
 508         unsigned int i;
 509         int d, m1, yy0, yy1, yy2, dow;
 510         const unsigned short int *myday =
 511           &__mon_yday[__isleap (year)][rule->m];
 512
 513         /* First add SECSPERDAY for each day in months before M.  */
 514         t += myday[-1] * SECSPERDAY;
 515
 516         /* Use Zeller's Congruence to get day-of-week of first day of month. */
 517         m1 = (rule->m + 9) % 12 + 1;
 518         yy0 = (rule->m <= 2) ? (year - 1) : year;
 519         yy1 = yy0 / 100;
 520         yy2 = yy0 % 100;
 521         dow = ((26 * m1 - 2) / 10 + 1 + yy2 + yy2 / 4 + yy1 / 4 - 2 * yy1) % 7;
 522         if (dow < 0)
 523           dow += 7;
 524
 525         /* DOW is the day-of-week of the first day of the month.  Get the
 526            day-of-month (zero-origin) of the first DOW day of the month.  */
 527         d = rule->d - dow;
 528         if (d < 0)
 529           d += 7;
 530         for (i = 1; i < rule->n; ++i)
 531           {
 532             if (d + 7 >= (int) myday[0] - myday[-1])
 533               break;
 534             d += 7;
 535           }
 536
 537         /* D is the day-of-month (zero-origin) of the day we want.  */
 538         t += d * SECSPERDAY;
 539       }
 540       break;
 541     }
 542
 543   /* T is now the Epoch-relative time of 0:00:00 GMT on the day we want.
 544      Just add the time of day and local offset from GMT, and we're done.  */
 545
 546   rule->change = t - rule->offset + rule->secs;
 547   rule->computed_for = year;
 548 }
 549
 550
 551 /* Figure out the correct timezone for TM and set `__tzname',
 552    `__timezone', and `__daylight' accordingly.  */
 553 void
 554 internal_function
 555 __tz_compute (timer, tm, use_localtime)
 556      time_t timer;
 557      struct tm *tm;
 558      int use_localtime;
 559 {
 560   compute_change (&tz_rules[0], 1900 + tm->tm_year);
 561   compute_change (&tz_rules[1], 1900 + tm->tm_year);
 562
 563   if (use_localtime)
 564     {
 565       int isdst;
 566
 567       /* We have to distinguish between northern and southern
 568          hemisphere.  For the latter the daylight saving time
 569          ends in the next year.  */
 570       if (__builtin_expect (tz_rules[0].change
 571                             > tz_rules[1].change, 0))
 572         isdst = (timer < tz_rules[1].change
 573                  || timer >= tz_rules[0].change);
 574       else
 575         isdst = (timer >= tz_rules[0].change
 576                  && timer < tz_rules[1].change);
 577       tm->tm_isdst = isdst;
 578       tm->tm_zone = __tzname[isdst];
 579       tm->tm_gmtoff = tz_rules[isdst].offset;
 580     }
 581 }
 582 \f
 583 /* Reinterpret the TZ environment variable and set `tzname'.  */
 584 #undef tzset
 585
 586 void
 587 __tzset (void)
 588 {
 589   __libc_lock_lock (tzset_lock);
 590
 591   tzset_internal (1, 1);
 592
 593   if (!__use_tzfile)
 594     {
 595       /* Set `tzname'.  */
 596       __tzname[0] = (char *) tz_rules[0].name;
 597       __tzname[1] = (char *) tz_rules[1].name;
 598     }
 599
 600   __libc_lock_unlock (tzset_lock);
 601 }
 602 weak_alias (__tzset, tzset)
 603 \f
 604 /* Return the `struct tm' representation of *TIMER in the local timezone.
 605    Use local time if USE_LOCALTIME is nonzero, UTC otherwise.  */
 606 struct tm *
 607 __tz_convert (const time_t *timer, int use_localtime, struct tm *tp)
 608 {
 609   long int leap_correction;
 610   int leap_extra_secs;
 611
 612   if (timer == NULL)
 613     {
 614       __set_errno (EINVAL);
 615       return NULL;
 616     }
 617
 618   __libc_lock_lock (tzset_lock);
 619
 620   /* Update internal database according to current TZ setting.
 621      POSIX.1 8.3.7.2 says that localtime_r is not required to set tzname.
 622      This is a good idea since this allows at least a bit more parallelism.  */
 623   tzset_internal (tp == &_tmbuf && use_localtime, 1);
 624
 625   if (__use_tzfile)
 626     __tzfile_compute (*timer, use_localtime, &leap_correction,
 627                       &leap_extra_secs, tp);
 628   else
 629     {
 630       if (! __offtime (timer, 0, tp))
 631         tp = NULL;
 632       else
 633         __tz_compute (*timer, tp, use_localtime);
 634       leap_correction = 0L;
 635       leap_extra_secs = 0;
 636     }
 637
 638   if (tp)
 639     {
 640       if (! use_localtime)
 641         {
 642           tp->tm_isdst = 0;
 643           tp->tm_zone = "GMT";
 644           tp->tm_gmtoff = 0L;
 645         }
 646
 647       if (__offtime (timer, tp->tm_gmtoff - leap_correction, tp))
 648         tp->tm_sec += leap_extra_secs;
 649       else
 650         tp = NULL;
 651     }
 652
 653   __libc_lock_unlock (tzset_lock);
 654
 655   return tp;
 656 }
 657
 658
 659 libc_freeres_fn (free_mem)
 660 {
 661   while (tzstring_list != NULL)
 662     {
 663       struct tzstring_l *old = tzstring_list;
 664
 665       tzstring_list = tzstring_list->next;
 666       free (old);
 667     }
 668   free (old_tz);
 669   old_tz = NULL;
 670 }