X-Git-Url: http://git.csclub.uwaterloo.ca/?p=kopensolaris-gnu%2Fglibc.git;a=blobdiff_plain;f=time%2Ftzfile.c;h=cfbdae68867f0238b52f387d6c249cab21b99110;hp=841f598c87ca99d0a951ff458671c6b0ab8630f1;hb=f8f163be7e94ff936153e93c73ce8283bfb82236;hpb=8edacff8b1c7482c47a74879cea8a5df6faecb26 diff --git a/time/tzfile.c b/time/tzfile.c index 841f598c87..cfbdae6886 100644 --- a/time/tzfile.c +++ b/time/tzfile.c @@ -1,36 +1,31 @@ -/* Copyright (C) 1991, 1992, 1993 Free Software Foundation, Inc. -This file is part of the GNU C Library. +/* Copyright (C) 1991,92,93,95,96,97,98,99 Free Software Foundation, Inc. + This file is part of the GNU C Library. -The GNU C Library is free software; you can redistribute it and/or -modify it under the terms of the GNU Library General Public License as -published by the Free Software Foundation; either version 2 of the -License, or (at your option) any later version. + The GNU C Library is free software; you can redistribute it and/or + modify it under the terms of the GNU Library General Public License as + published by the Free Software Foundation; either version 2 of the + License, or (at your option) any later version. -The GNU C Library is distributed in the hope that it will be useful, -but WITHOUT ANY WARRANTY; without even the implied warranty of -MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -Library General Public License for more details. + The GNU C Library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Library General Public License for more details. -You should have received a copy of the GNU Library General Public -License along with the GNU C Library; see the file COPYING.LIB. If -not, write to the Free Software Foundation, Inc., 675 Mass Ave, -Cambridge, MA 02139, USA. */ + You should have received a copy of the GNU Library General Public + License along with the GNU C Library; see the file COPYING.LIB. If not, + write to the Free Software Foundation, Inc., 59 Temple Place - Suite 330, + Boston, MA 02111-1307, USA. */ -#include -#include +#include +#include #include -#include +#include #include -#include +#include +#include #define NOID -#include - -#ifndef HAVE_GNU_LD -#define __tzname tzname -#define __daylight daylight -#define __timezone timezone -#endif +#include int __use_tzfile = 0; @@ -39,7 +34,8 @@ struct ttinfo long int offset; /* Seconds east of GMT. */ unsigned char isdst; /* Used to set tm_isdst. */ unsigned char idx; /* Index into `zone_names'. */ - unsigned char isstd; /* Transition times are standard time. */ + unsigned char isstd; /* Transition times are in standard time. */ + unsigned char isgmt; /* Transition times are in GMT. */ }; struct leap @@ -48,7 +44,8 @@ struct leap long int change; /* Seconds of correction to apply. */ }; -static void compute_tzname_max __P ((size_t)); +static struct ttinfo *find_transition (time_t timer) internal_function; +static void compute_tzname_max (size_t) internal_function; static size_t num_transitions; static time_t *transitions = NULL; @@ -56,18 +53,41 @@ static unsigned char *type_idxs = NULL; static size_t num_types; static struct ttinfo *types = NULL; static char *zone_names = NULL; +static long int rule_stdoff; +static long int rule_dstoff; static size_t num_leaps; static struct leap *leaps = NULL; -#define uc2ul(x) _uc2ul((unsigned char *) (x)) -#define _uc2ul(x) \ - ((x)[3] + ((x)[2] << CHAR_BIT) + ((x)[1] << (2 * CHAR_BIT)) + \ - ((x)[0] << (3 * CHAR_BIT))) +#include +#include + +/* Decode the four bytes at PTR as a signed integer in network byte order. */ +static inline int +decode (const void *ptr) +{ + if ((BYTE_ORDER == BIG_ENDIAN) && sizeof (int) == 4) + return *(const int *) ptr; + else if (BYTE_ORDER == LITTLE_ENDIAN && sizeof (int) == 4) + return bswap_32 (*(const int *) ptr); + else + { + const unsigned char *p = ptr; + int result = *p & (1 << (CHAR_BIT - 1)) ? ~0 : 0; + + result = (result << 8) | *p++; + result = (result << 8) | *p++; + result = (result << 8) | *p++; + result = (result << 8) | *p++; + + return result; + } +} void -DEFUN(__tzfile_read, (file), CONST char *file) +__tzfile_read (const char *file) { - size_t num_isstd; + static const char default_tzdir[] = TZDIR; + size_t num_isstd, num_isgmt; register FILE *f; struct tzhead tzhead; size_t chars; @@ -76,51 +96,82 @@ DEFUN(__tzfile_read, (file), CONST char *file) __use_tzfile = 0; if (transitions != NULL) - free((PTR) transitions); + free ((void *) transitions); transitions = NULL; if (type_idxs != NULL) - free((PTR) type_idxs); + free ((void *) type_idxs); type_idxs = NULL; if (types != NULL) - free((PTR) types); + free ((void *) types); types = NULL; if (zone_names != NULL) - free((PTR) zone_names); + free ((void *) zone_names); zone_names = NULL; if (leaps != NULL) - free((PTR) leaps); + free ((void *) leaps); leaps = NULL; - if (file == NULL || *file == '\0') + if (file == NULL) + /* No user specification; use the site-wide default. */ file = TZDEFAULT; + else if (*file == '\0') + /* User specified the empty string; use UTC with no leap seconds. */ + return; + else + { + /* We must not allow to read an arbitrary file in a setuid + program. So we fail for any file which is not in the + directory hierachy starting at TZDIR + and which is not the system wide default TZDEFAULT. */ + if (__libc_enable_secure + && ((*file == '/' + && memcmp (file, TZDEFAULT, sizeof TZDEFAULT) + && memcmp (file, default_tzdir, sizeof (default_tzdir) - 1)) + || strstr (file, "../") != NULL)) + /* This test is certainly a bit too restrictive but it should + catch all critical cases. */ + return; + } if (*file != '/') { - static CONST char tzdir[] = TZDIR; - register CONST unsigned int len = strlen(file) + 1; - char *new = (char *) __alloca(sizeof(tzdir) + len); - memcpy(new, tzdir, sizeof(tzdir) - 1); - new[sizeof(tzdir) - 1] = '/'; - memcpy(&new[sizeof(tzdir)], file, len); + const char *tzdir; + unsigned int len, tzdir_len; + char *new, *tmp; + + tzdir = __secure_getenv ("TZDIR"); + if (tzdir == NULL || *tzdir == '\0') + { + tzdir = default_tzdir; + tzdir_len = sizeof (default_tzdir) - 1; + } + else + tzdir_len = strlen (tzdir); + len = strlen (file) + 1; + new = (char *) __alloca (tzdir_len + 1 + len); + tmp = __mempcpy (new, tzdir, tzdir_len); + *tmp++ = '/'; + __mempcpy (tmp, file, len); file = new; } - f = fopen(file, "r"); + f = fopen (file, "r"); if (f == NULL) return; - if (fread((PTR) &tzhead, sizeof(tzhead), 1, f) != 1) + if (fread_unlocked ((void *) &tzhead, sizeof (tzhead), 1, f) != 1) goto lose; - num_transitions = (size_t) uc2ul(tzhead.tzh_timecnt); - num_types = (size_t) uc2ul(tzhead.tzh_typecnt); - chars = (size_t) uc2ul(tzhead.tzh_charcnt); - num_leaps = (size_t) uc2ul(tzhead.tzh_leapcnt); - num_isstd = (size_t) uc2ul(tzhead.tzh_ttisstdcnt); + num_transitions = (size_t) decode (tzhead.tzh_timecnt); + num_types = (size_t) decode (tzhead.tzh_typecnt); + chars = (size_t) decode (tzhead.tzh_charcnt); + num_leaps = (size_t) decode (tzhead.tzh_leapcnt); + num_isstd = (size_t) decode (tzhead.tzh_ttisstdcnt); + num_isgmt = (size_t) decode (tzhead.tzh_ttisgmtcnt); if (num_transitions > 0) { - transitions = (time_t *) malloc (num_transitions * sizeof(time_t)); + transitions = (time_t *) malloc (num_transitions * sizeof (time_t)); if (transitions == NULL) goto lose; type_idxs = (unsigned char *) malloc (num_transitions); @@ -146,41 +197,61 @@ DEFUN(__tzfile_read, (file), CONST char *file) goto lose; } - if (fread((PTR) transitions, sizeof(time_t), - num_transitions, f) != num_transitions || - fread((PTR) type_idxs, 1, num_transitions, f) != num_transitions) + if (sizeof (time_t) < 4) + abort (); + + if (fread_unlocked (transitions, 4, num_transitions, f) != num_transitions + || fread_unlocked (type_idxs, 1, num_transitions, f) != num_transitions) goto lose; + /* Check for bogus indices in the data file, so we can hereafter + safely use type_idxs[T] as indices into `types' and never crash. */ for (i = 0; i < num_transitions; ++i) - transitions[i] = uc2ul (&transitions[i]); + if (type_idxs[i] >= num_types) + goto lose; + + if (BYTE_ORDER != BIG_ENDIAN || sizeof (time_t) != 4) + { + /* Decode the transition times, stored as 4-byte integers in + network (big-endian) byte order. We work from the end of + the array so as not to clobber the next element to be + processed when sizeof (time_t) > 4. */ + i = num_transitions; + while (i-- > 0) + transitions[i] = decode ((char *) transitions + i * 4); + } for (i = 0; i < num_types; ++i) { unsigned char x[4]; - if (fread((PTR) x, 1, 4, f) != 4 || - fread((PTR) &types[i].isdst, 1, 1, f) != 1 || - fread((PTR) &types[i].idx, 1, 1, f) != 1) + if (fread_unlocked (x, 1, 4, f) != 4 + || fread_unlocked (&types[i].isdst, 1, 1, f) != 1 + || fread_unlocked (&types[i].idx, 1, 1, f) != 1) goto lose; - types[i].offset = (long int) uc2ul(x); + if (types[i].isdst > 1) + goto lose; + if (types[i].idx >= chars) /* Bogus index in data file. */ + goto lose; + types[i].offset = (long int) decode (x); } - if (fread((PTR) zone_names, 1, chars, f) != chars) + if (fread_unlocked (zone_names, 1, chars, f) != chars) goto lose; for (i = 0; i < num_leaps; ++i) { unsigned char x[4]; - if (fread((PTR) x, 1, sizeof(x), f) != sizeof(x)) + if (fread_unlocked (x, 1, sizeof (x), f) != sizeof (x)) goto lose; - leaps[i].transition = (time_t) uc2ul(x); - if (fread((PTR) x, 1, sizeof(x), f) != sizeof(x)) + leaps[i].transition = (time_t) decode (x); + if (fread_unlocked (x, 1, sizeof (x), f) != sizeof (x)) goto lose; - leaps[i].change = (long int) uc2ul(x); + leaps[i].change = (long int) decode (x); } for (i = 0; i < num_isstd; ++i) { - char c = getc(f); + int c = getc_unlocked (f); if (c == EOF) goto lose; types[i].isstd = c != 0; @@ -188,23 +259,103 @@ DEFUN(__tzfile_read, (file), CONST char *file) while (i < num_types) types[i++].isstd = 0; - (void) fclose(f); + for (i = 0; i < num_isgmt; ++i) + { + int c = getc_unlocked (f); + if (c == EOF) + goto lose; + types[i].isgmt = c != 0; + } + while (i < num_types) + types[i++].isgmt = 0; + + fclose (f); + + /* First "register" all timezone names. */ + for (i = 0; i < num_types; ++i) + (void) __tzstring (&zone_names[types[i].idx]); + + /* Find the standard and daylight time offsets used by the rule file. + We choose the offsets in the types of each flavor that are + transitioned to earliest in time. */ + __tzname[0] = NULL; + __tzname[1] = NULL; + for (i = num_transitions; i > 0; ) + { + int type = type_idxs[--i]; + int dst = types[type].isdst; + + if (__tzname[dst] == NULL) + { + int idx = types[type].idx; + + __tzname[dst] = __tzstring (&zone_names[idx]); + + if (__tzname[1 - dst] != NULL) + break; + } + } + if (__tzname[0] == NULL) + { + /* This should only happen if there are no transition rules. + In this case there should be only one single type. */ + assert (num_types == 1); + __tzname[0] = __tzstring (zone_names); + } + if (__tzname[1] == NULL) + __tzname[1] = __tzname[0]; compute_tzname_max (chars); - + + if (num_transitions == 0) + /* Use the first rule (which should also be the only one). */ + rule_stdoff = rule_dstoff = types[0].offset; + else + { + int stdoff_set = 0, dstoff_set = 0; + rule_stdoff = rule_dstoff = 0; + i = num_transitions - 1; + do + { + if (!stdoff_set && !types[type_idxs[i]].isdst) + { + stdoff_set = 1; + rule_stdoff = types[type_idxs[i]].offset; + } + else if (!dstoff_set && types[type_idxs[i]].isdst) + { + dstoff_set = 1; + rule_dstoff = types[type_idxs[i]].offset; + } + if (stdoff_set && dstoff_set) + break; + } + while (i-- > 0); + + if (!dstoff_set) + rule_dstoff = rule_stdoff; + } + + __daylight = rule_stdoff != rule_dstoff; + __timezone = -rule_stdoff; + __use_tzfile = 1; return; - lose:; - (void) fclose(f); + lose: + fclose (f); } +/* The user specified a hand-made timezone, but not its DST rules. + We will use the names and offsets from the user, and the rules + from the TZDEFRULES file. */ + void -DEFUN(__tzfile_default, (std, dst, stdoff, dstoff), - char *std AND char *dst AND - long int stdoff AND long int dstoff) +__tzfile_default (const char *std, const char *dst, + long int stdoff, long int dstoff) { size_t stdlen, dstlen, i; + int isdst; __tzfile_read (TZDEFRULES); if (!__use_tzfile) @@ -216,8 +367,10 @@ DEFUN(__tzfile_default, (std, dst, stdoff, dstoff), return; } + /* Ignore the zone names read from the file. */ free (zone_names); + /* Use the names the user specified. */ stdlen = strlen (std) + 1; dstlen = strlen (dst) + 1; zone_names = malloc (stdlen + dstlen); @@ -226,32 +379,66 @@ DEFUN(__tzfile_default, (std, dst, stdoff, dstoff), __use_tzfile = 0; return; } - memcpy (zone_names, std, stdlen); - memcpy (&zone_names[stdlen], dst, dstlen); + __mempcpy (__mempcpy (zone_names, std, stdlen), dst, dstlen); - for (i = 0; i < num_types; ++i) - if (types[i].isdst) - { - types[i].idx = stdlen; - if (dst[0] != '\0') - types[i].offset = dstoff; - } - else - { - types[i].idx = 0; - if (dst[0] != '\0') - types[i].offset = stdoff; - } + /* Now there are only two zones, regardless of what the file contained. */ + num_types = 2; + + /* Now correct the transition times for the user-specified standard and + daylight offsets from GMT. */ + isdst = 0; + for (i = 0; i < num_transitions; ++i) + { + struct ttinfo *trans_type = &types[type_idxs[i]]; + + /* We will use only types 0 (standard) and 1 (daylight). + Fix up this transition to point to whichever matches + the flavor of its original type. */ + type_idxs[i] = trans_type->isdst; + + if (trans_type->isgmt) + /* The transition time is in GMT. No correction to apply. */ ; + else if (isdst && !trans_type->isstd) + /* The type says this transition is in "local wall clock time", and + wall clock time as of the previous transition was DST. Correct + for the difference between the rule's DST offset and the user's + DST offset. */ + transitions[i] += dstoff - rule_dstoff; + else + /* This transition is in "local wall clock time", and wall clock + time as of this iteration is non-DST. Correct for the + difference between the rule's standard offset and the user's + standard offset. */ + transitions[i] += stdoff - rule_stdoff; + + /* The DST state of "local wall clock time" for the next iteration is + as specified by this transition. */ + isdst = trans_type->isdst; + } + + /* Reset types 0 and 1 to describe the user's settings. */ + types[0].idx = 0; + types[0].offset = stdoff; + types[0].isdst = 0; + types[1].idx = stdlen; + types[1].offset = dstoff; + types[1].isdst = 1; + + /* Reset the zone names to point to the user's names. */ + __tzname[0] = (char *) std; + __tzname[1] = (char *) dst; + + /* Set the timezone. */ + __timezone = -types[0].offset; compute_tzname_max (stdlen + dstlen); } -int -DEFUN(__tzfile_compute, (timer, leap_correct, leap_hit), - time_t timer AND long int *leap_correct AND int *leap_hit) +static struct ttinfo * +internal_function +find_transition (time_t timer) { - struct ttinfo *info; - register size_t i; + size_t i; if (num_transitions == 0 || timer < transitions[0]) { @@ -274,14 +461,51 @@ DEFUN(__tzfile_compute, (timer, leap_correct, leap_hit), i = type_idxs[i - 1]; } - info = &types[i]; - __daylight = info->isdst; - __timezone = info->offset; - for (i = 0; i < num_types && i < sizeof (__tzname) / sizeof (__tzname[0]); - ++i) - __tzname[types[i].isdst] = &zone_names[types[i].idx]; - if (info->isdst < sizeof (__tzname) / sizeof (__tzname[0])) - __tzname[info->isdst] = &zone_names[info->idx]; + return &types[i]; +} + +int +__tzfile_compute (time_t timer, int use_localtime, + long int *leap_correct, int *leap_hit, + struct tm *tp) +{ + register size_t i; + + if (use_localtime) + { + struct ttinfo *info = find_transition (timer); + __daylight = rule_stdoff != rule_dstoff; + __timezone = -rule_stdoff; + __tzname[0] = NULL; + __tzname[1] = NULL; + for (i = num_transitions; i > 0; ) + { + int type = type_idxs[--i]; + int dst = types[type].isdst; + int idx = types[type].idx; + + if (__tzname[dst] == NULL) + { + __tzname[dst] = __tzstring (&zone_names[idx]); + + if (__tzname[1 - dst] != NULL) + break; + } + } + if (__tzname[0] == NULL) + { + /* This should only happen if there are no transition rules. + In this case there should be only one single type. */ + assert (num_types == 1); + __tzname[0] = __tzstring (zone_names); + } + if (__tzname[1] == NULL) + /* There is no daylight saving time. */ + __tzname[1] = __tzname[0]; + tp->tm_isdst = info->isdst; + tp->tm_zone = &zone_names[info->idx]; + tp->tm_gmtoff = info->offset; + } *leap_correct = 0L; *leap_hit = 0; @@ -301,9 +525,9 @@ DEFUN(__tzfile_compute, (timer, leap_correct, leap_hit), leaps[i].change > leaps[i - 1].change)) { *leap_hit = 1; - while (i > 0 && - leaps[i].transition == leaps[i - 1].transition + 1 && - leaps[i].change == leaps[i - 1].change + 1) + while (i > 0 + && leaps[i].transition == leaps[i - 1].transition + 1 + && leaps[i].change == leaps[i - 1].change + 1) { ++*leap_hit; --i; @@ -313,11 +537,10 @@ DEFUN(__tzfile_compute, (timer, leap_correct, leap_hit), return 1; } -void -DEFUN(compute_tzname_max, (chars), size_t chars) +static void +internal_function +compute_tzname_max (size_t chars) { - extern long int __tzname_cur_max; /* Defined in __tzset.c. */ - const char *p; p = zone_names; @@ -326,7 +549,8 @@ DEFUN(compute_tzname_max, (chars), size_t chars) const char *start = p; while (*p != '\0') ++p; - if (p - start > __tzname_cur_max) + if ((size_t) (p - start) > __tzname_cur_max) __tzname_cur_max = p - start; - } while (++p < &zone_names[chars]); + } + while (++p < &zone_names[chars]); }