1 /* Copyright (C) 1991, 1992, 1993, 1995 Free Software Foundation, Inc.
2 This file is part of the GNU C Library.
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.
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.
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. */
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. */
42 time_t transition
; /* Time the transition takes effect. */
43 long int change
; /* Seconds of correction to apply. */
46 static void compute_tzname_max
__P ((size_t));
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
;
59 /* Decode the four bytes at PTR as a signed integer in network byte order. */
61 decode (const void *ptr
)
63 if ((BYTE_ORDER
== BIG_ENDIAN
) && sizeof (int) == 4)
64 return *(const int *) ptr
;
67 const unsigned char *p
= ptr
;
68 int result
= *p
& (1 << (CHAR_BIT
- 1)) ? ~0 : 0;
70 result
= (result
<< 8) | *p
++;
71 result
= (result
<< 8) | *p
++;
72 result
= (result
<< 8) | *p
++;
73 result
= (result
<< 8) | *p
++;
80 DEFUN(__tzfile_read
, (file
), CONST
char *file
)
82 size_t num_isstd
, num_isgmt
;
90 if (transitions
!= NULL
)
91 free((PTR
) transitions
);
93 if (type_idxs
!= NULL
)
94 free((PTR
) type_idxs
);
99 if (zone_names
!= NULL
)
100 free((PTR
) zone_names
);
106 if (file
== NULL
|| *file
== '\0')
111 static CONST
char tzdir
[] = TZDIR
;
112 register CONST
unsigned int len
= strlen(file
) + 1;
113 char *new = (char *) __alloca(sizeof(tzdir
) + len
);
114 memcpy(new, tzdir
, sizeof(tzdir
) - 1);
115 new[sizeof(tzdir
) - 1] = '/';
116 memcpy(&new[sizeof(tzdir
)], file
, len
);
120 f
= fopen(file
, "r");
124 if (fread((PTR
) &tzhead
, sizeof(tzhead
), 1, f
) != 1)
127 num_transitions
= (size_t) decode (tzhead
.tzh_timecnt
);
128 num_types
= (size_t) decode (tzhead
.tzh_typecnt
);
129 chars
= (size_t) decode (tzhead
.tzh_charcnt
);
130 num_leaps
= (size_t) decode (tzhead
.tzh_leapcnt
);
131 num_isstd
= (size_t) decode (tzhead
.tzh_ttisstdcnt
);
132 num_isgmt
= (size_t) decode (tzhead
.tzh_ttisgmtcnt
);
134 if (num_transitions
> 0)
136 transitions
= (time_t *) malloc (num_transitions
* sizeof(time_t));
137 if (transitions
== NULL
)
139 type_idxs
= (unsigned char *) malloc (num_transitions
);
140 if (type_idxs
== NULL
)
145 types
= (struct ttinfo
*) malloc (num_types
* sizeof (struct ttinfo
));
151 zone_names
= (char *) malloc (chars
);
152 if (zone_names
== NULL
)
157 leaps
= (struct leap
*) malloc (num_leaps
* sizeof (struct leap
));
162 if (sizeof (time_t) < 4)
165 if (fread((PTR
) transitions
, 4, num_transitions
, f
) != num_transitions
||
166 fread((PTR
) type_idxs
, 1, num_transitions
, f
) != num_transitions
)
169 if (BYTE_ORDER
!= BIG_ENDIAN
|| sizeof (time_t) != 4)
171 /* Decode the transition times, stored as 4-byte integers in
172 network (big-endian) byte order. We work from the end of
173 the array so as not to clobber the next element to be
174 processed when sizeof (time_t) > 4. */
177 transitions
[i
] = decode ((char *) transitions
+ i
*4);
180 for (i
= 0; i
< num_types
; ++i
)
183 if (fread((PTR
) x
, 1, 4, f
) != 4 ||
184 fread((PTR
) &types
[i
].isdst
, 1, 1, f
) != 1 ||
185 fread((PTR
) &types
[i
].idx
, 1, 1, f
) != 1)
187 types
[i
].offset
= (long int) decode (x
);
190 if (fread((PTR
) zone_names
, 1, chars
, f
) != chars
)
193 for (i
= 0; i
< num_leaps
; ++i
)
196 if (fread((PTR
) x
, 1, sizeof(x
), f
) != sizeof(x
))
198 leaps
[i
].transition
= (time_t) decode (x
);
199 if (fread((PTR
) x
, 1, sizeof(x
), f
) != sizeof(x
))
201 leaps
[i
].change
= (long int) decode (x
);
204 for (i
= 0; i
< num_isstd
; ++i
)
209 types
[i
].isstd
= c
!= 0;
211 while (i
< num_types
)
212 types
[i
++].isstd
= 0;
214 for (i
= 0; i
< num_isgmt
; ++i
)
219 types
[i
].isgmt
= c
!= 0;
221 while (i
< num_types
)
222 types
[i
++].isgmt
= 0;
226 compute_tzname_max (chars
);
235 /* The user specified a hand-made timezone, but not its DST rules.
236 We will use the names and offsets from the user, and the rules
237 from the TZDEFRULES file. */
240 DEFUN(__tzfile_default
, (std
, dst
, stdoff
, dstoff
),
241 char *std AND
char *dst AND
242 long int stdoff AND
long int dstoff
)
244 size_t stdlen
, dstlen
, i
;
245 long int rule_offset
, rule_stdoff
, rule_dstoff
;
248 __tzfile_read (TZDEFRULES
);
258 /* Ignore the zone names read from the file. */
261 /* Use the names the user specified. */
262 stdlen
= strlen (std
) + 1;
263 dstlen
= strlen (dst
) + 1;
264 zone_names
= malloc (stdlen
+ dstlen
);
265 if (zone_names
== NULL
)
270 memcpy (zone_names
, std
, stdlen
);
271 memcpy (&zone_names
[stdlen
], dst
, dstlen
);
273 /* Find the standard and daylight time offsets used by the rule file.
274 We choose the offsets in the types of each flavor that are
275 transitioned to earliest in time. */
276 rule_stdoff
= rule_dstoff
= 0;
277 for (i
= 0; i
< num_transitions
; ++i
)
279 if (!rule_stdoff
&& !types
[type_idxs
[i
]].isdst
)
280 rule_stdoff
= types
[type_idxs
[i
]].offset
;
281 if (!rule_dstoff
&& types
[type_idxs
[i
]].isdst
)
282 rule_dstoff
= types
[type_idxs
[i
]].offset
;
283 if (rule_stdoff
&& rule_dstoff
)
287 /* Now correct the transition times for the user-specified standard and
288 daylight offsets from GMT. */
290 rule_offset
= rule_offset
;
291 for (i
= 0; i
< num_transitions
; ++i
)
293 struct ttinfo
*trans_type
= &types
[type_idxs
[i
]];
295 /* We will use only types 0 (standard) and 1 (daylight).
296 Fix up this transition to point to whichever matches
297 the flavor of its original type. */
298 type_idxs
[i
] = trans_type
->isdst
;
300 if (trans_type
->isgmt
)
301 /* The transition time is in GMT. No correction to apply. */ ;
302 else if (isdst
&& !trans_type
->isstd
)
303 /* The type says this transition is in "local wall clock time", and
304 wall clock time as of the previous transition was DST. Correct
305 for the difference between the rule's DST offset and the user's
307 transitions
[i
] += dstoff
- rule_dstoff
;
309 /* This transition is in "local wall clock time", and wall clock
310 time as of this iteration is non-DST. Correct for the
311 difference between the rule's standard offset and the user's
313 transitions
[i
] += stdoff
- rule_stdoff
;
315 /* The DST state of "local wall clock time" for the next iteration is
316 as specified by this transition. */
317 isdst
= trans_type
->isdst
;
320 /* Reset types 0 and 1 to describe the user's settings. */
322 types
[0].offset
= stdoff
;
324 types
[1].idx
= stdlen
;
325 types
[1].offset
= dstoff
;
328 compute_tzname_max (stdlen
+ dstlen
);
332 DEFUN(__tzfile_compute
, (timer
, leap_correct
, leap_hit
),
333 time_t timer AND
long int *leap_correct AND
int *leap_hit
)
338 if (num_transitions
== 0 || timer
< transitions
[0])
340 /* TIMER is before any transition (or there are no transitions).
341 Choose the first non-DST type
342 (or the first if they're all DST types). */
344 while (i
< num_types
&& types
[i
].isdst
)
351 /* Find the first transition after TIMER, and
352 then pick the type of the transition before it. */
353 for (i
= 1; i
< num_transitions
; ++i
)
354 if (timer
< transitions
[i
])
356 i
= type_idxs
[i
- 1];
360 __daylight
= info
->isdst
;
361 __timezone
= info
->offset
;
362 for (i
= 0; i
< num_types
&& i
< sizeof (__tzname
) / sizeof (__tzname
[0]);
364 __tzname
[types
[i
].isdst
] = &zone_names
[types
[i
].idx
];
365 if (info
->isdst
< sizeof (__tzname
) / sizeof (__tzname
[0]))
366 __tzname
[info
->isdst
] = &zone_names
[info
->idx
];
371 /* Find the last leap second correction transition time before TIMER. */
376 while (timer
< leaps
[i
].transition
);
378 /* Apply its correction. */
379 *leap_correct
= leaps
[i
].change
;
381 if (timer
== leaps
[i
].transition
&& /* Exactly at the transition time. */
382 ((i
== 0 && leaps
[i
].change
> 0) ||
383 leaps
[i
].change
> leaps
[i
- 1].change
))
387 leaps
[i
].transition
== leaps
[i
- 1].transition
+ 1 &&
388 leaps
[i
].change
== leaps
[i
- 1].change
+ 1)
399 DEFUN(compute_tzname_max
, (chars
), size_t chars
)
401 extern long int __tzname_cur_max
; /* Defined in __tzset.c. */
408 const char *start
= p
;
411 if (p
- start
> __tzname_cur_max
)
412 __tzname_cur_max
= p
- start
;
413 } while (++p
< &zone_names
[chars
]);