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