time/tzfile.c

   1 /* Copyright (C) 1991, 1992, 1993, 1995 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 Library General Public License as
   6 published by the Free Software Foundation; either version 2 of the
   7 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 Library General Public License for more details.
  13
  14 You should have received a copy of the GNU Library General Public
  15 License along with the GNU C Library; see the file COPYING.LIB.  If
  16 not, write to the Free Software Foundation, Inc., 675 Mass Ave,
  17 Cambridge, MA 02139, USA.  */
  18
  19 #include <ansidecl.h>
  20 #include <stdlib.h>
  21 #include <stdio.h>
  22 #include <time.h>
  23 #include <string.h>
  24 #include <limits.h>
  25
  26 #define NOID
  27 #include <tzfile.h>
  28
  29 int __use_tzfile = 0;
  30
  31 struct ttinfo
  32   {
  33     long int offset;            /* Seconds east of GMT.  */
  34     unsigned char isdst;        /* Used to set tm_isdst.  */
  35     unsigned char idx;          /* Index into `zone_names'.  */
  36     unsigned char isstd;        /* Transition times are in standard time.  */
  37     unsigned char isgmt;        /* Transition times are in GMT.  */
  38   };
  39
  40 struct leap
  41   {
  42     time_t transition;          /* Time the transition takes effect.  */
  43     long int change;            /* Seconds of correction to apply.  */
  44   };
  45
  46 static void compute_tzname_max __P ((size_t));
  47
  48 static size_t num_transitions;
  49 static time_t *transitions = NULL;
  50 static unsigned char *type_idxs = NULL;
  51 static size_t num_types;
  52 static struct ttinfo *types = NULL;
  53 static char *zone_names = NULL;
  54 static size_t num_leaps;
  55 static struct leap *leaps = NULL;
  56
  57 #define uc2ul(x)        _uc2ul((unsigned char *) (x))
  58 #define _uc2ul(x)                                                             \
  59   ((x)[3] + ((x)[2] << CHAR_BIT) + ((x)[1] << (2 * CHAR_BIT)) +               \
  60    ((x)[0] << (3 * CHAR_BIT)))
  61
  62 void
  63 DEFUN(__tzfile_read, (file), CONST char *file)
  64 {
  65   size_t num_isstd, num_isgmt;
  66   register FILE *f;
  67   struct tzhead tzhead;
  68   size_t chars;
  69   register size_t i;
  70
  71   __use_tzfile = 0;
  72
  73   if (transitions != NULL)
  74     free((PTR) transitions);
  75   transitions = NULL;
  76   if (type_idxs != NULL)
  77     free((PTR) type_idxs);
  78   type_idxs = NULL;
  79   if (types != NULL)
  80     free((PTR) types);
  81   types = NULL;
  82   if (zone_names != NULL)
  83     free((PTR) zone_names);
  84   zone_names = NULL;
  85   if (leaps != NULL)
  86     free((PTR) leaps);
  87   leaps = NULL;
  88
  89   if (file == NULL || *file == '\0')
  90     file = TZDEFAULT;
  91
  92   if (*file != '/')
  93     {
  94       static CONST char tzdir[] = TZDIR;
  95       register CONST unsigned int len = strlen(file) + 1;
  96       char *new = (char *) __alloca(sizeof(tzdir) + len);
  97       memcpy(new, tzdir, sizeof(tzdir) - 1);
  98       new[sizeof(tzdir) - 1] = '/';
  99       memcpy(&new[sizeof(tzdir)], file, len);
 100       file = new;
 101     }
 102
 103   f = fopen(file, "r");
 104   if (f == NULL)
 105     return;
 106
 107   if (fread((PTR) &tzhead, sizeof(tzhead), 1, f) != 1)
 108     goto lose;
 109
 110   num_transitions = (size_t) uc2ul(tzhead.tzh_timecnt);
 111   num_types = (size_t) uc2ul (tzhead.tzh_typecnt);
 112   chars = (size_t) uc2ul (tzhead.tzh_charcnt);
 113   num_leaps = (size_t) uc2ul (tzhead.tzh_leapcnt);
 114   num_isstd = (size_t) uc2ul (tzhead.tzh_ttisstdcnt);
 115   num_isgmt = (size_t) uc2ul (tzhead.tzh_ttisgmtcnt);
 116
 117   if (num_transitions > 0)
 118     {
 119       transitions = (time_t *) malloc (num_transitions * sizeof(time_t));
 120       if (transitions == NULL)
 121         goto lose;
 122       type_idxs = (unsigned char *) malloc (num_transitions);
 123       if (type_idxs == NULL)
 124         goto lose;
 125     }
 126   if (num_types > 0)
 127     {
 128       types = (struct ttinfo *) malloc (num_types * sizeof (struct ttinfo));
 129       if (types == NULL)
 130         goto lose;
 131     }
 132   if (chars > 0)
 133     {
 134       zone_names = (char *) malloc (chars);
 135       if (zone_names == NULL)
 136         goto lose;
 137     }
 138   if (num_leaps > 0)
 139     {
 140       leaps = (struct leap *) malloc (num_leaps * sizeof (struct leap));
 141       if (leaps == NULL)
 142         goto lose;
 143     }
 144
 145   if (fread((PTR) transitions, sizeof(time_t),
 146             num_transitions, f) != num_transitions ||
 147       fread((PTR) type_idxs, 1, num_transitions, f) != num_transitions)
 148     goto lose;
 149
 150   for (i = 0; i < num_transitions; ++i)
 151     transitions[i] = uc2ul (&transitions[i]);
 152
 153   for (i = 0; i < num_types; ++i)
 154     {
 155       unsigned char x[4];
 156       if (fread((PTR) x, 1, 4, f) != 4 ||
 157           fread((PTR) &types[i].isdst, 1, 1, f) != 1 ||
 158           fread((PTR) &types[i].idx, 1, 1, f) != 1)
 159         goto lose;
 160       types[i].offset = (long int) uc2ul(x);
 161     }
 162
 163   if (fread((PTR) zone_names, 1, chars, f) != chars)
 164     goto lose;
 165
 166   for (i = 0; i < num_leaps; ++i)
 167     {
 168       unsigned char x[4];
 169       if (fread((PTR) x, 1, sizeof(x), f) != sizeof(x))
 170         goto lose;
 171       leaps[i].transition = (time_t) uc2ul(x);
 172       if (fread((PTR) x, 1, sizeof(x), f) != sizeof(x))
 173         goto lose;
 174       leaps[i].change = (long int) uc2ul(x);
 175     }
 176
 177   for (i = 0; i < num_isstd; ++i)
 178     {
 179       char c = getc(f);
 180       if (c == EOF)
 181         goto lose;
 182       types[i].isstd = c != 0;
 183     }
 184   while (i < num_types)
 185     types[i++].isstd = 0;
 186
 187   for (i = 0; i < num_isgmt; ++i)
 188     {
 189       char c = getc(f);
 190       if (c == EOF)
 191         goto lose;
 192       types[i].isgmt = c != 0;
 193     }
 194   while (i < num_types)
 195     types[i++].isgmt = 0;
 196
 197   (void) fclose(f);
 198
 199   compute_tzname_max (chars);
 200
 201   __use_tzfile = 1;
 202   return;
 203
 204  lose:;
 205   (void) fclose(f);
 206 }
 207 \f
 208 /* The user specified a hand-made timezone, but not its DST rules.
 209    We will use the names and offsets from the user, and the rules
 210    from the TZDEFRULES file.  */
 211
 212 void
 213 DEFUN(__tzfile_default, (std, dst, stdoff, dstoff),
 214       char *std AND char *dst AND
 215       long int stdoff AND long int dstoff)
 216 {
 217   size_t stdlen, dstlen, i;
 218   long int rule_offset, rule_stdoff, rule_dstoff;
 219   int isdst;
 220
 221   __tzfile_read (TZDEFRULES);
 222   if (!__use_tzfile)
 223     return;
 224
 225   if (num_types < 2)
 226     {
 227       __use_tzfile = 0;
 228       return;
 229     }
 230
 231   /* Ignore the zone names read from the file.  */
 232   free (zone_names);
 233
 234   /* Use the names the user specified.  */
 235   stdlen = strlen (std) + 1;
 236   dstlen = strlen (dst) + 1;
 237   zone_names = malloc (stdlen + dstlen);
 238   if (zone_names == NULL)
 239     {
 240       __use_tzfile = 0;
 241       return;
 242     }
 243   memcpy (zone_names, std, stdlen);
 244   memcpy (&zone_names[stdlen], dst, dstlen);
 245
 246   /* Find the standard and daylight time offsets used by the rule file.
 247      We choose the offsets in the types of each flavor that are
 248      transitioned to earliest in time.  */
 249   rule_dstoff = 0;
 250   for (i = 0; i < num_transitions; ++i)
 251     {
 252       if (!rule_stdoff && !types[type_idxs[i]].isdst)
 253         rule_stdoff = types[type_idxs[i]].offset;
 254       if (!rule_dstoff && types[type_idxs[i]].isdst)
 255         rule_dstoff = types[type_idxs[i]].offset;
 256       if (rule_stdoff && rule_dstoff)
 257         break;
 258     }
 259
 260   /* Now correct the transition times for the user-specified standard and
 261      daylight offsets from GMT.  */
 262   isdst = 0;
 263   rule_offset = rule_offset;
 264   for (i = 0; i < num_transitions; ++i)
 265     {
 266       struct ttinfo *trans_type = &types[type_idxs[i]];
 267
 268       /* We will use only types 0 (standard) and 1 (daylight).
 269          Fix up this transition to point to whichever matches
 270          the flavor of its original type.  */
 271       type_idxs[i] = trans_type->isdst;
 272
 273       if (trans_type->isgmt)
 274         /* The transition time is in GMT.  No correction to apply.  */ ;
 275       else if (isdst && !trans_type->isstd)
 276         /* The type says this transition is in "local wall clock time", and
 277            wall clock time as of the previous transition was DST.  Correct
 278            for the difference between the rule's DST offset and the user's
 279            DST offset.  */
 280         transitions[i] += dstoff - rule_dstoff;
 281       else
 282         /* This transition is in "local wall clock time", and wall clock
 283            time as of this iteration is non-DST.  Correct for the
 284            difference between the rule's standard offset and the user's
 285            standard offset.  */
 286         transitions[i] += stdoff - rule_stdoff;
 287
 288       /* The DST state of "local wall clock time" for the next iteration is
 289          as specified by this transition.  */
 290       isdst = trans_type->isdst;
 291     }
 292
 293   /* Reset types 0 and 1 to describe the user's settings.  */
 294   types[0].idx = 0;
 295   types[0].offset = stdoff;
 296   types[0].isdst = 0;
 297   types[1].idx = stdlen;
 298   types[1].offset = dstoff;
 299   types[1].isdst = 1;
 300
 301   compute_tzname_max (stdlen + dstlen);
 302 }
 303 \f
 304 int
 305 DEFUN(__tzfile_compute, (timer, leap_correct, leap_hit),
 306       time_t timer AND long int *leap_correct AND int *leap_hit)
 307 {
 308   struct ttinfo *info;
 309   register size_t i;
 310
 311   if (num_transitions == 0 || timer < transitions[0])
 312     {
 313       /* TIMER is before any transition (or there are no transitions).
 314          Choose the first non-DST type
 315          (or the first if they're all DST types).  */
 316       i = 0;
 317       while (i < num_types && types[i].isdst)
 318         ++i;
 319       if (i == num_types)
 320         i = 0;
 321     }
 322   else
 323     {
 324       /* Find the first transition after TIMER, and
 325          then pick the type of the transition before it.  */
 326       for (i = 1; i < num_transitions; ++i)
 327         if (timer < transitions[i])
 328           break;
 329       i = type_idxs[i - 1];
 330     }
 331
 332   info = &types[i];
 333   __daylight = info->isdst;
 334   __timezone = info->offset;
 335   for (i = 0; i < num_types && i < sizeof (__tzname) / sizeof (__tzname[0]);
 336        ++i)
 337     __tzname[types[i].isdst] = &zone_names[types[i].idx];
 338   if (info->isdst < sizeof (__tzname) / sizeof (__tzname[0]))
 339     __tzname[info->isdst] = &zone_names[info->idx];
 340
 341   *leap_correct = 0L;
 342   *leap_hit = 0;
 343
 344   /* Find the last leap second correction transition time before TIMER.  */
 345   i = num_leaps;
 346   do
 347     if (i-- == 0)
 348       return 1;
 349   while (timer < leaps[i].transition);
 350
 351   /* Apply its correction.  */
 352   *leap_correct = leaps[i].change;
 353
 354   if (timer == leaps[i].transition && /* Exactly at the transition time.  */
 355       ((i == 0 && leaps[i].change > 0) ||
 356        leaps[i].change > leaps[i - 1].change))
 357     {
 358       *leap_hit = 1;
 359       while (i > 0 &&
 360              leaps[i].transition == leaps[i - 1].transition + 1 &&
 361              leaps[i].change == leaps[i - 1].change + 1)
 362         {
 363           ++*leap_hit;
 364           --i;
 365         }
 366     }
 367
 368   return 1;
 369 }
 370 \f
 371 void
 372 DEFUN(compute_tzname_max, (chars), size_t chars)
 373 {
 374   extern long int __tzname_cur_max; /* Defined in __tzset.c. */
 375
 376   const char *p;
 377
 378   p = zone_names;
 379   do
 380     {
 381       const char *start = p;
 382       while (*p != '\0')
 383         ++p;
 384       if (p - start > __tzname_cur_max)
 385         __tzname_cur_max = p - start;
 386     } while (++p < &zone_names[chars]);
 387 }