time/tzset.c

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