time/tzfile.c

   1 /* Copyright (C) 1991-1993,1995-2001,2003,2004,2006,2007,2009
   2    Free Software Foundation, Inc.
   3    This file is part of the GNU C Library.
   4
   5    The GNU C Library is free software; you can redistribute it and/or
   6    modify it under the terms of the GNU Lesser General Public
   7    License as published by the Free Software Foundation; either
   8    version 2.1 of the License, or (at your option) any later version.
   9
  10    The GNU C Library is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13    Lesser General Public License for more details.
  14
  15    You should have received a copy of the GNU Lesser General Public
  16    License along with the GNU C Library; if not, write to the Free
  17    Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
  18    02111-1307 USA.  */
  19
  20 #include <assert.h>
  21 #include <limits.h>
  22 #include <stdio.h>
  23 #include <stdio_ext.h>
  24 #include <stdlib.h>
  25 #include <string.h>
  26 #include <time.h>
  27 #include <unistd.h>
  28 #include <sys/stat.h>
  29
  30 #define NOID
  31 #include <timezone/tzfile.h>
  32
  33 int __use_tzfile;
  34 static dev_t tzfile_dev;
  35 static ino64_t tzfile_ino;
  36 static time_t tzfile_mtime;
  37
  38 struct ttinfo
  39   {
  40     long int offset;            /* Seconds east of GMT.  */
  41     unsigned char isdst;        /* Used to set tm_isdst.  */
  42     unsigned char idx;          /* Index into `zone_names'.  */
  43     unsigned char isstd;        /* Transition times are in standard time.  */
  44     unsigned char isgmt;        /* Transition times are in GMT.  */
  45   };
  46
  47 struct leap
  48   {
  49     time_t transition;          /* Time the transition takes effect.  */
  50     long int change;            /* Seconds of correction to apply.  */
  51   };
  52
  53 static void compute_tzname_max (size_t) internal_function;
  54
  55 static size_t num_transitions;
  56 libc_freeres_ptr (static time_t *transitions);
  57 static unsigned char *type_idxs;
  58 static size_t num_types;
  59 static struct ttinfo *types;
  60 static char *zone_names;
  61 static long int rule_stdoff;
  62 static long int rule_dstoff;
  63 static size_t num_leaps;
  64 static struct leap *leaps;
  65 static char *tzspec;
  66
  67 #include <endian.h>
  68 #include <byteswap.h>
  69
  70 /* Decode the four bytes at PTR as a signed integer in network byte order.  */
  71 static inline int
  72 __attribute ((always_inline))
  73 decode (const void *ptr)
  74 {
  75   if (BYTE_ORDER == BIG_ENDIAN && sizeof (int) == 4)
  76     return *(const int *) ptr;
  77   if (sizeof (int) == 4)
  78     return bswap_32 (*(const int *) ptr);
  79
  80   const unsigned char *p = ptr;
  81   int result = *p & (1 << (CHAR_BIT - 1)) ? ~0 : 0;
  82
  83   result = (result << 8) | *p++;
  84   result = (result << 8) | *p++;
  85   result = (result << 8) | *p++;
  86   result = (result << 8) | *p++;
  87
  88   return result;
  89 }
  90
  91
  92 static inline int64_t
  93 __attribute ((always_inline))
  94 decode64 (const void *ptr)
  95 {
  96   if ((BYTE_ORDER == BIG_ENDIAN))
  97     return *(const int64_t *) ptr;
  98
  99   return bswap_64 (*(const int64_t *) ptr);
 100 }
 101
 102
 103 void
 104 __tzfile_read (const char *file, size_t extra, char **extrap)
 105 {
 106   static const char default_tzdir[] = TZDIR;
 107   size_t num_isstd, num_isgmt;
 108   register FILE *f;
 109   struct tzhead tzhead;
 110   size_t chars;
 111   register size_t i;
 112   size_t total_size;
 113   size_t types_idx;
 114   size_t leaps_idx;
 115   int was_using_tzfile = __use_tzfile;
 116   int trans_width = 4;
 117   size_t tzspec_len;
 118
 119   if (sizeof (time_t) != 4 && sizeof (time_t) != 8)
 120     abort ();
 121
 122   __use_tzfile = 0;
 123
 124   if (file == NULL)
 125     /* No user specification; use the site-wide default.  */
 126     file = TZDEFAULT;
 127   else if (*file == '\0')
 128     /* User specified the empty string; use UTC with no leap seconds.  */
 129     goto ret_free_transitions;
 130   else
 131     {
 132       /* We must not allow to read an arbitrary file in a setuid
 133          program.  So we fail for any file which is not in the
 134          directory hierachy starting at TZDIR
 135          and which is not the system wide default TZDEFAULT.  */
 136       if (__libc_enable_secure
 137           && ((*file == '/'
 138                && memcmp (file, TZDEFAULT, sizeof TZDEFAULT)
 139                && memcmp (file, default_tzdir, sizeof (default_tzdir) - 1))
 140               || strstr (file, "../") != NULL))
 141         /* This test is certainly a bit too restrictive but it should
 142            catch all critical cases.  */
 143         goto ret_free_transitions;
 144     }
 145
 146   if (*file != '/')
 147     {
 148       const char *tzdir;
 149       unsigned int len, tzdir_len;
 150       char *new, *tmp;
 151
 152       tzdir = getenv ("TZDIR");
 153       if (tzdir == NULL || *tzdir == '\0')
 154         {
 155           tzdir = default_tzdir;
 156           tzdir_len = sizeof (default_tzdir) - 1;
 157         }
 158       else
 159         tzdir_len = strlen (tzdir);
 160       len = strlen (file) + 1;
 161       new = (char *) __alloca (tzdir_len + 1 + len);
 162       tmp = __mempcpy (new, tzdir, tzdir_len);
 163       *tmp++ = '/';
 164       memcpy (tmp, file, len);
 165       file = new;
 166     }
 167
 168   /* If we were already using tzfile, check whether the file changed.  */
 169   struct stat64 st;
 170   if (was_using_tzfile
 171       && stat64 (file, &st) == 0
 172       && tzfile_ino == st.st_ino && tzfile_dev == st.st_dev
 173       && tzfile_mtime == st.st_mtime)
 174     {
 175       /* Nothing to do.  */
 176       __use_tzfile = 1;
 177       return;
 178     }
 179
 180   /* Note the file is opened with cancellation in the I/O functions
 181      disabled.  */
 182   f = fopen (file, "rc");
 183   if (f == NULL)
 184     goto ret_free_transitions;
 185
 186   /* Get information about the file we are actually using.  */
 187   if (fstat64 (fileno (f), &st) != 0)
 188     {
 189       fclose (f);
 190       goto ret_free_transitions;
 191     }
 192
 193   free ((void *) transitions);
 194   transitions = NULL;
 195
 196   /* Remember the inode and device number and modification time.  */
 197   tzfile_dev = st.st_dev;
 198   tzfile_ino = st.st_ino;
 199   tzfile_mtime = st.st_mtime;
 200
 201   /* No threads reading this stream.  */
 202   __fsetlocking (f, FSETLOCKING_BYCALLER);
 203
 204  read_again:
 205   if (__builtin_expect (fread_unlocked ((void *) &tzhead, sizeof (tzhead),
 206                                         1, f) != 1, 0)
 207       || memcmp (tzhead.tzh_magic, TZ_MAGIC, sizeof (tzhead.tzh_magic)) != 0)
 208     goto lose;
 209
 210   num_transitions = (size_t) decode (tzhead.tzh_timecnt);
 211   num_types = (size_t) decode (tzhead.tzh_typecnt);
 212   chars = (size_t) decode (tzhead.tzh_charcnt);
 213   num_leaps = (size_t) decode (tzhead.tzh_leapcnt);
 214   num_isstd = (size_t) decode (tzhead.tzh_ttisstdcnt);
 215   num_isgmt = (size_t) decode (tzhead.tzh_ttisgmtcnt);
 216
 217   /* For platforms with 64-bit time_t we use the new format if available.  */
 218   if (sizeof (time_t) == 8 && trans_width == 4
 219       && tzhead.tzh_version[0] != '\0')
 220     {
 221       /* We use the 8-byte format.  */
 222       trans_width = 8;
 223
 224       /* Position the stream before the second header.  */
 225       size_t to_skip = (num_transitions * (4 + 1)
 226                         + num_types * 6
 227                         + chars
 228                         + num_leaps * 8
 229                         + num_isstd
 230                         + num_isgmt);
 231       if (fseek (f, to_skip, SEEK_CUR) != 0)
 232         goto lose;
 233
 234       goto read_again;
 235     }
 236
 237   total_size = num_transitions * (sizeof (time_t) + 1);
 238   total_size = ((total_size + __alignof__ (struct ttinfo) - 1)
 239                 & ~(__alignof__ (struct ttinfo) - 1));
 240   types_idx = total_size;
 241   total_size += num_types * sizeof (struct ttinfo) + chars;
 242   total_size = ((total_size + __alignof__ (struct leap) - 1)
 243                 & ~(__alignof__ (struct leap) - 1));
 244   leaps_idx = total_size;
 245   total_size += num_leaps * sizeof (struct leap);
 246   tzspec_len = (sizeof (time_t) == 8 && trans_width == 8
 247                 ? st.st_size - (ftello (f)
 248                                 + num_transitions * (8 + 1)
 249                                 + num_types * 6
 250                                 + chars
 251                                 + num_leaps * 12
 252                                 + num_isstd
 253                                 + num_isgmt) - 1 : 0);
 254
 255   /* Allocate enough memory including the extra block requested by the
 256      caller.  */
 257   transitions = (time_t *) malloc (total_size + tzspec_len + extra);
 258   if (transitions == NULL)
 259     goto lose;
 260
 261   type_idxs = (unsigned char *) transitions + (num_transitions
 262                                                * sizeof (time_t));
 263   types = (struct ttinfo *) ((char *) transitions + types_idx);
 264   zone_names = (char *) types + num_types * sizeof (struct ttinfo);
 265   leaps = (struct leap *) ((char *) transitions + leaps_idx);
 266   if (sizeof (time_t) == 8 && trans_width == 8)
 267     tzspec = (char *) leaps + num_leaps * sizeof (struct leap) + extra;
 268   else
 269     tzspec = NULL;
 270   if (extra > 0)
 271     *extrap = (char *) &leaps[num_leaps];
 272
 273   if (sizeof (time_t) == 4 || __builtin_expect (trans_width == 8, 1))
 274     {
 275       if (__builtin_expect (fread_unlocked (transitions, trans_width + 1,
 276                                             num_transitions, f)
 277                             != num_transitions, 0))
 278         goto lose;
 279     }
 280   else
 281     {
 282       if (__builtin_expect (fread_unlocked (transitions, 4, num_transitions, f)
 283                             != num_transitions, 0)
 284           || __builtin_expect (fread_unlocked (type_idxs, 1, num_transitions,
 285                                                f) != num_transitions, 0))
 286         goto lose;
 287     }
 288
 289   /* Check for bogus indices in the data file, so we can hereafter
 290      safely use type_idxs[T] as indices into `types' and never crash.  */
 291   for (i = 0; i < num_transitions; ++i)
 292     if (__builtin_expect (type_idxs[i] >= num_types, 0))
 293       goto lose;
 294
 295   if ((BYTE_ORDER != BIG_ENDIAN && (sizeof (time_t) == 4 || trans_width == 4))
 296       || (BYTE_ORDER == BIG_ENDIAN && sizeof (time_t) == 8
 297           && trans_width == 4))
 298     {
 299       /* Decode the transition times, stored as 4-byte integers in
 300          network (big-endian) byte order.  We work from the end of
 301          the array so as not to clobber the next element to be
 302          processed when sizeof (time_t) > 4.  */
 303       i = num_transitions;
 304       while (i-- > 0)
 305         transitions[i] = decode ((char *) transitions + i * 4);
 306     }
 307   else if (BYTE_ORDER != BIG_ENDIAN && sizeof (time_t) == 8)
 308     {
 309       /* Decode the transition times, stored as 8-byte integers in
 310          network (big-endian) byte order.  */
 311       for (i = 0; i < num_transitions; ++i)
 312         transitions[i] = decode64 ((char *) transitions + i * 8);
 313     }
 314
 315   for (i = 0; i < num_types; ++i)
 316     {
 317       unsigned char x[4];
 318       int c;
 319       if (__builtin_expect (fread_unlocked (x, 1, sizeof (x), f) != sizeof (x),
 320                             0))
 321         goto lose;
 322       c = getc_unlocked (f);
 323       if (__builtin_expect ((unsigned int) c > 1u, 0))
 324         goto lose;
 325       types[i].isdst = c;
 326       c = getc_unlocked (f);
 327       if (__builtin_expect ((size_t) c > chars, 0))
 328         /* Bogus index in data file.  */
 329         goto lose;
 330       types[i].idx = c;
 331       types[i].offset = (long int) decode (x);
 332     }
 333
 334   if (__builtin_expect (fread_unlocked (zone_names, 1, chars, f) != chars, 0))
 335     goto lose;
 336
 337   for (i = 0; i < num_leaps; ++i)
 338     {
 339       unsigned char x[8];
 340       if (__builtin_expect (fread_unlocked (x, 1, trans_width, f)
 341                             != trans_width, 0))
 342         goto lose;
 343       if (sizeof (time_t) == 4 || trans_width == 4)
 344         leaps[i].transition = (time_t) decode (x);
 345       else
 346         leaps[i].transition = (time_t) decode64 (x);
 347
 348       if (__builtin_expect (fread_unlocked (x, 1, 4, f) != 4, 0))
 349         goto lose;
 350       leaps[i].change = (long int) decode (x);
 351     }
 352
 353   for (i = 0; i < num_isstd; ++i)
 354     {
 355       int c = getc_unlocked (f);
 356       if (__builtin_expect (c == EOF, 0))
 357         goto lose;
 358       types[i].isstd = c != 0;
 359     }
 360   while (i < num_types)
 361     types[i++].isstd = 0;
 362
 363   for (i = 0; i < num_isgmt; ++i)
 364     {
 365       int c = getc_unlocked (f);
 366       if (__builtin_expect (c == EOF, 0))
 367         goto lose;
 368       types[i].isgmt = c != 0;
 369     }
 370   while (i < num_types)
 371     types[i++].isgmt = 0;
 372
 373   /* Read the POSIX TZ-style information if possible.  */
 374   if (sizeof (time_t) == 8 && tzspec != NULL)
 375     {
 376       /* Skip over the newline first.  */
 377       if (getc_unlocked (f) != '\n'
 378           || (fread_unlocked (tzspec, 1, tzspec_len - 1, f)
 379               != tzspec_len - 1))
 380         tzspec = NULL;
 381       else
 382         tzspec[tzspec_len - 1] = '\0';
 383     }
 384   else if (sizeof (time_t) == 4 && tzhead.tzh_version[0] != '\0')
 385     {
 386       /* Get the TZ string.  */
 387       if (__builtin_expect (fread_unlocked ((void *) &tzhead, sizeof (tzhead),
 388                                             1, f) != 1, 0)
 389           || (memcmp (tzhead.tzh_magic, TZ_MAGIC, sizeof (tzhead.tzh_magic))
 390               != 0))
 391         goto lose;
 392
 393       size_t num_transitions2 = (size_t) decode (tzhead.tzh_timecnt);
 394       size_t num_types2 = (size_t) decode (tzhead.tzh_typecnt);
 395       size_t chars2 = (size_t) decode (tzhead.tzh_charcnt);
 396       size_t num_leaps2 = (size_t) decode (tzhead.tzh_leapcnt);
 397       size_t num_isstd2 = (size_t) decode (tzhead.tzh_ttisstdcnt);
 398       size_t num_isgmt2 = (size_t) decode (tzhead.tzh_ttisgmtcnt);
 399
 400       /* Position the stream before the second header.  */
 401       size_t to_skip = (num_transitions2 * (8 + 1)
 402                         + num_types2 * 6
 403                         + chars2
 404                         + num_leaps2 * 12
 405                         + num_isstd2
 406                         + num_isgmt2);
 407       off_t off;
 408       if (fseek (f, to_skip, SEEK_CUR) != 0
 409           || (off = ftello (f)) < 0
 410           || st.st_size < off + 2)
 411         goto lose;
 412
 413       tzspec_len = st.st_size - off - 1;
 414       char *tzstr = alloca (tzspec_len);
 415       if (getc_unlocked (f) != '\n'
 416           || (fread_unlocked (tzstr, 1, tzspec_len - 1, f) != tzspec_len - 1))
 417         goto lose;
 418       tzstr[tzspec_len - 1] = '\0';
 419       tzspec = __tzstring (tzstr);
 420     }
 421
 422   /* Don't use an empty TZ string.  */
 423   if (tzspec != NULL && tzspec[0] == '\0')
 424     tzspec = NULL;
 425
 426   fclose (f);
 427
 428   /* First "register" all timezone names.  */
 429   for (i = 0; i < num_types; ++i)
 430     (void) __tzstring (&zone_names[types[i].idx]);
 431
 432   /* Find the standard and daylight time offsets used by the rule file.
 433      We choose the offsets in the types of each flavor that are
 434      transitioned to earliest in time.  */
 435   __tzname[0] = NULL;
 436   __tzname[1] = NULL;
 437   for (i = num_transitions; i > 0; )
 438     {
 439       int type = type_idxs[--i];
 440       int dst = types[type].isdst;
 441
 442       if (__tzname[dst] == NULL)
 443         {
 444           int idx = types[type].idx;
 445
 446           __tzname[dst] = __tzstring (&zone_names[idx]);
 447
 448           if (__tzname[1 - dst] != NULL)
 449             break;
 450         }
 451     }
 452   if (__tzname[0] == NULL)
 453     {
 454       /* This should only happen if there are no transition rules.
 455          In this case there should be only one single type.  */
 456       assert (num_types == 1);
 457       __tzname[0] = __tzstring (zone_names);
 458     }
 459   if (__tzname[1] == NULL)
 460     __tzname[1] = __tzname[0];
 461
 462   compute_tzname_max (chars);
 463
 464   if (num_transitions == 0)
 465     /* Use the first rule (which should also be the only one).  */
 466     rule_stdoff = rule_dstoff = types[0].offset;
 467   else
 468     {
 469       int stdoff_set = 0, dstoff_set = 0;
 470       rule_stdoff = rule_dstoff = 0;
 471       i = num_transitions - 1;
 472       do
 473         {
 474           if (!stdoff_set && !types[type_idxs[i]].isdst)
 475             {
 476               stdoff_set = 1;
 477               rule_stdoff = types[type_idxs[i]].offset;
 478             }
 479           else if (!dstoff_set && types[type_idxs[i]].isdst)
 480             {
 481               dstoff_set = 1;
 482               rule_dstoff = types[type_idxs[i]].offset;
 483             }
 484           if (stdoff_set && dstoff_set)
 485             break;
 486         }
 487       while (i-- > 0);
 488
 489       if (!dstoff_set)
 490         rule_dstoff = rule_stdoff;
 491     }
 492
 493   __daylight = rule_stdoff != rule_dstoff;
 494   __timezone = -rule_stdoff;
 495
 496   __use_tzfile = 1;
 497   return;
 498
 499  lose:
 500   fclose (f);
 501  ret_free_transitions:
 502   free ((void *) transitions);
 503   transitions = NULL;
 504 }
 505 \f
 506 /* The user specified a hand-made timezone, but not its DST rules.
 507    We will use the names and offsets from the user, and the rules
 508    from the TZDEFRULES file.  */
 509
 510 void
 511 __tzfile_default (const char *std, const char *dst,
 512                   long int stdoff, long int dstoff)
 513 {
 514   size_t stdlen = strlen (std) + 1;
 515   size_t dstlen = strlen (dst) + 1;
 516   size_t i;
 517   int isdst;
 518   char *cp;
 519
 520   __tzfile_read (TZDEFRULES, stdlen + dstlen, &cp);
 521   if (!__use_tzfile)
 522     return;
 523
 524   if (num_types < 2)
 525     {
 526       __use_tzfile = 0;
 527       return;
 528     }
 529
 530   /* Ignore the zone names read from the file and use the given ones
 531      instead.  */
 532   __mempcpy (__mempcpy (cp, std, stdlen), dst, dstlen);
 533   zone_names = cp;
 534
 535   /* Now there are only two zones, regardless of what the file contained.  */
 536   num_types = 2;
 537
 538   /* Now correct the transition times for the user-specified standard and
 539      daylight offsets from GMT.  */
 540   isdst = 0;
 541   for (i = 0; i < num_transitions; ++i)
 542     {
 543       struct ttinfo *trans_type = &types[type_idxs[i]];
 544
 545       /* We will use only types 0 (standard) and 1 (daylight).
 546          Fix up this transition to point to whichever matches
 547          the flavor of its original type.  */
 548       type_idxs[i] = trans_type->isdst;
 549
 550       if (trans_type->isgmt)
 551         /* The transition time is in GMT.  No correction to apply.  */ ;
 552       else if (isdst && !trans_type->isstd)
 553         /* The type says this transition is in "local wall clock time", and
 554            wall clock time as of the previous transition was DST.  Correct
 555            for the difference between the rule's DST offset and the user's
 556            DST offset.  */
 557         transitions[i] += dstoff - rule_dstoff;
 558       else
 559         /* This transition is in "local wall clock time", and wall clock
 560            time as of this iteration is non-DST.  Correct for the
 561            difference between the rule's standard offset and the user's
 562            standard offset.  */
 563         transitions[i] += stdoff - rule_stdoff;
 564
 565       /* The DST state of "local wall clock time" for the next iteration is
 566          as specified by this transition.  */
 567       isdst = trans_type->isdst;
 568     }
 569
 570   /* Now that we adjusted the transitions to the requested offsets,
 571      reset the rule_stdoff and rule_dstoff values appropriately.  They
 572      are used elsewhere.  */
 573   rule_stdoff = stdoff;
 574   rule_dstoff = dstoff;
 575
 576   /* Reset types 0 and 1 to describe the user's settings.  */
 577   types[0].idx = 0;
 578   types[0].offset = stdoff;
 579   types[0].isdst = 0;
 580   types[1].idx = stdlen;
 581   types[1].offset = dstoff;
 582   types[1].isdst = 1;
 583
 584   /* Reset the zone names to point to the user's names.  */
 585   __tzname[0] = (char *) std;
 586   __tzname[1] = (char *) dst;
 587
 588   /* Set the timezone.  */
 589   __timezone = -types[0].offset;
 590
 591   compute_tzname_max (stdlen + dstlen);
 592 }
 593 \f
 594 void
 595 __tzfile_compute (time_t timer, int use_localtime,
 596                   long int *leap_correct, int *leap_hit,
 597                   struct tm *tp)
 598 {
 599   register size_t i;
 600
 601   if (use_localtime)
 602     {
 603       __tzname[0] = NULL;
 604       __tzname[1] = NULL;
 605
 606       if (__builtin_expect (num_transitions == 0 || timer < transitions[0], 0))
 607         {
 608           /* TIMER is before any transition (or there are no transitions).
 609              Choose the first non-DST type
 610              (or the first if they're all DST types).  */
 611           i = 0;
 612           while (i < num_types && types[i].isdst)
 613             {
 614               if (__tzname[1] == NULL)
 615                 __tzname[1] = __tzstring (&zone_names[types[i].idx]);
 616
 617               ++i;
 618             }
 619
 620           if (i == num_types)
 621             i = 0;
 622           __tzname[0] = __tzstring (&zone_names[types[i].idx]);
 623           if (__tzname[1] == NULL)
 624             {
 625               size_t j = i;
 626               while (j < num_types)
 627                 if (types[j].isdst)
 628                   {
 629                     __tzname[1] = __tzstring (&zone_names[types[j].idx]);
 630                     break;
 631                   }
 632                 else
 633                   ++j;
 634             }
 635         }
 636       else if (__builtin_expect (timer >= transitions[num_transitions - 1], 0))
 637         {
 638           if (__builtin_expect (tzspec == NULL, 0))
 639             {
 640             use_last:
 641               i = num_transitions;
 642               goto found;
 643             }
 644
 645           /* Parse the POSIX TZ-style string.  */
 646           __tzset_parse_tz (tzspec);
 647
 648           /* Convert to broken down structure.  If this fails do not
 649              use the string.  */
 650           if (__builtin_expect (! __offtime (&timer, 0, tp), 0))
 651             goto use_last;
 652
 653           /* Use the rules from the TZ string to compute the change.  */
 654           __tz_compute (timer, tp, 1);
 655
 656           /* If tzspec comes from posixrules loaded by __tzfile_default,
 657              override the STD and DST zone names with the ones user
 658              requested in TZ envvar.  */
 659           if (__builtin_expect (zone_names == (char *) &leaps[num_leaps], 0))
 660             {
 661               assert (num_types == 2);
 662               __tzname[0] = __tzstring (zone_names);
 663               __tzname[1] = __tzstring (&zone_names[strlen (zone_names) + 1]);
 664             }
 665
 666           goto leap;
 667         }
 668       else
 669         {
 670           /* Find the first transition after TIMER, and
 671              then pick the type of the transition before it.  */
 672           size_t lo = 0;
 673           size_t hi = num_transitions - 1;
 674           /* Assume that DST is changing twice a year and guess initial
 675              search spot from it.
 676              Half of a gregorian year has on average 365.2425 * 86400 / 2
 677              = 15778476 seconds.  */
 678           i = (transitions[num_transitions - 1] - timer) / 15778476;
 679           if (i < num_transitions)
 680             {
 681               i = num_transitions - 1 - i;
 682               if (timer < transitions[i])
 683                 {
 684                   if (i < 10 || timer >= transitions[i - 10])
 685                     {
 686                       /* Linear search.  */
 687                       while (timer < transitions[i - 1])
 688                         --i;
 689                       goto found;
 690                     }
 691                   hi = i - 10;
 692                 }
 693               else
 694                 {
 695                   if (i + 10 >= num_transitions || timer < transitions[i + 10])
 696                     {
 697                       /* Linear search.  */
 698                       while (timer >= transitions[i])
 699                         ++i;
 700                       goto found;
 701                     }
 702                   lo = i + 10;
 703                 }
 704             }
 705
 706           /* Binary search.  */
 707           /* assert (timer >= transitions[lo] && timer < transitions[hi]); */
 708           while (lo + 1 < hi)
 709             {
 710               i = (lo + hi) / 2;
 711               if (timer < transitions[i])
 712                 hi = i;
 713               else
 714                 lo = i;
 715             }
 716           i = hi;
 717
 718         found:
 719           /* assert (timer >= transitions[i - 1]
 720              && (i == num_transitions || timer < transitions[i])); */
 721           __tzname[types[type_idxs[i - 1]].isdst]
 722             = __tzstring (&zone_names[types[type_idxs[i - 1]].idx]);
 723           size_t j = i;
 724           while (j < num_transitions)
 725             {
 726               int type = type_idxs[j];
 727               int dst = types[type].isdst;
 728               int idx = types[type].idx;
 729
 730               if (__tzname[dst] == NULL)
 731                 {
 732                   __tzname[dst] = __tzstring (&zone_names[idx]);
 733
 734                   if (__tzname[1 - dst] != NULL)
 735                     break;
 736                 }
 737
 738               ++j;
 739             }
 740
 741           if (__builtin_expect (__tzname[0] == NULL, 0))
 742             __tzname[0] = __tzname[1];
 743
 744           i = type_idxs[i - 1];
 745         }
 746
 747       struct ttinfo *info = &types[i];
 748       __daylight = rule_stdoff != rule_dstoff;
 749       __timezone = -rule_stdoff;
 750
 751       if (__tzname[0] == NULL)
 752         {
 753           /* This should only happen if there are no transition rules.
 754              In this case there should be only one single type.  */
 755           assert (num_types == 1);
 756           __tzname[0] = __tzstring (zone_names);
 757         }
 758       if (__tzname[1] == NULL)
 759         /* There is no daylight saving time.  */
 760         __tzname[1] = __tzname[0];
 761       tp->tm_isdst = info->isdst;
 762       assert (strcmp (&zone_names[info->idx], __tzname[tp->tm_isdst]) == 0);
 763       tp->tm_zone = __tzname[tp->tm_isdst];
 764       tp->tm_gmtoff = info->offset;
 765     }
 766
 767  leap:
 768   *leap_correct = 0L;
 769   *leap_hit = 0;
 770
 771   /* Find the last leap second correction transition time before TIMER.  */
 772   i = num_leaps;
 773   do
 774     if (i-- == 0)
 775       return;
 776   while (timer < leaps[i].transition);
 777
 778   /* Apply its correction.  */
 779   *leap_correct = leaps[i].change;
 780
 781   if (timer == leaps[i].transition && /* Exactly at the transition time.  */
 782       ((i == 0 && leaps[i].change > 0) ||
 783        leaps[i].change > leaps[i - 1].change))
 784     {
 785       *leap_hit = 1;
 786       while (i > 0
 787              && leaps[i].transition == leaps[i - 1].transition + 1
 788              && leaps[i].change == leaps[i - 1].change + 1)
 789         {
 790           ++*leap_hit;
 791           --i;
 792         }
 793     }
 794 }
 795 \f
 796 static void
 797 internal_function
 798 compute_tzname_max (size_t chars)
 799 {
 800   const char *p;
 801
 802   p = zone_names;
 803   do
 804     {
 805       const char *start = p;
 806       while (*p != '\0')
 807         ++p;
 808       if ((size_t) (p - start) > __tzname_cur_max)
 809         __tzname_cur_max = p - start;
 810     }
 811   while (++p < &zone_names[chars]);
 812 }