11 #define malloc __libc_malloc
18 char *__tzname[2] = { 0, 0 };
20 weak_alias(__timezone, timezone);
21 weak_alias(__daylight, daylight);
22 weak_alias(__tzname, tzname);
24 static char std_name[TZNAME_MAX+1];
25 static char dst_name[TZNAME_MAX+1];
26 const char __utc[] = "UTC";
29 static int r0[5], r1[5];
31 static const unsigned char *zi, *trans, *index, *types, *abbrevs, *abbrevs_end;
32 static size_t map_size;
34 static char old_tz_buf[32];
35 static char *old_tz = old_tz_buf;
36 static size_t old_tz_size = sizeof old_tz_buf;
38 static volatile int lock[1];
39 volatile int *const __timezone_lockptr = lock;
41 static int getint(const char **p)
44 for (x=0; **p-'0'<10U; (*p)++) x = **p-'0' + 10*x;
48 static int getoff(const char **p)
54 } else if (**p == '+') {
57 int off = 3600*getint(p);
66 return neg ? -off : off;
69 static void getrule(const char **p, int rule[5])
71 int r = rule[0] = **p;
78 ++*p; rule[1] = getint(p);
79 ++*p; rule[2] = getint(p);
80 ++*p; rule[3] = getint(p);
91 static void getname(char *d, const char **p)
96 for (i=0; (*p)[i] && (*p)[i]!='>'; i++)
97 if (i<TZNAME_MAX) d[i] = (*p)[i];
100 for (i=0; ((*p)[i]|32)-'a'<26U; i++)
101 if (i<TZNAME_MAX) d[i] = (*p)[i];
104 d[i<TZNAME_MAX?i:TZNAME_MAX] = 0;
107 #define VEC(...) ((const unsigned char[]){__VA_ARGS__})
109 static uint32_t zi_read32(const unsigned char *z)
111 return (unsigned)z[0]<<24 | z[1]<<16 | z[2]<<8 | z[3];
114 static size_t zi_dotprod(const unsigned char *z, const unsigned char *v, size_t n)
118 for (y=0; n; n--, z+=4, v++) {
125 static void do_tzset()
127 char buf[NAME_MAX+25], *pathname=buf+24;
128 const char *try, *s, *p;
129 const unsigned char *map = 0;
131 static const char search[] =
132 "/usr/share/zoneinfo/\0/share/zoneinfo/\0/etc/zoneinfo/\0";
135 if (!s) s = "/etc/localtime";
138 if (old_tz && !strcmp(s, old_tz)) return;
140 for (i=0; i<5; i++) r0[i] = r1[i] = 0;
142 if (zi) __munmap((void *)zi, map_size);
144 /* Cache the old value of TZ to check if it has changed. Avoid
145 * free so as not to pull it into static programs. Growth
146 * strategy makes it so free would have minimal benefit anyway. */
148 if (i > PATH_MAX+1) s = __utc, i = 3;
149 if (i >= old_tz_size) {
151 if (i >= old_tz_size) old_tz_size = i+1;
152 if (old_tz_size > PATH_MAX+2) old_tz_size = PATH_MAX+2;
153 old_tz = malloc(old_tz_size);
155 if (old_tz) memcpy(old_tz, s, i+1);
157 /* Non-suid can use an absolute tzfile pathname or a relative
158 * pathame beginning with "."; in secure mode, only the
159 * standard path will be searched. */
160 if (*s == ':' || ((p=strchr(s, '/')) && !memchr(s, ',', p-s))) {
162 if (*s == '/' || *s == '.') {
163 if (!libc.secure || !strcmp(s, "/etc/localtime"))
164 map = __map_file(s, &map_size);
166 size_t l = strlen(s);
167 if (l <= NAME_MAX && !strchr(s, '.')) {
168 memcpy(pathname, s, l+1);
170 for (try=search; !map && *try; try+=l+1) {
172 memcpy(pathname-l, try, l);
173 map = __map_file(pathname-l, &map_size);
179 if (map && (map_size < 44 || memcmp(map, "TZif", 4))) {
180 __munmap((void *)map, map_size);
188 if (sizeof(time_t) > 4 && map[4]=='2') {
189 size_t skip = zi_dotprod(zi+20, VEC(1,1,8,5,6,1), 6);
190 trans = zi+skip+44+44;
195 index = trans + (zi_read32(trans-12) << scale);
196 types = index + zi_read32(trans-12);
197 abbrevs = types + 6*zi_read32(trans-8);
198 abbrevs_end = abbrevs + zi_read32(trans-4);
199 if (zi[map_size-1] == '\n') {
200 for (s = (const char *)zi+map_size-2; *s!='\n'; s--);
203 const unsigned char *p;
204 __tzname[0] = __tzname[1] = 0;
205 __daylight = __timezone = dst_off = 0;
206 for (p=types; p<abbrevs; p+=6) {
207 if (!p[4] && !__tzname[0]) {
208 __tzname[0] = (char *)abbrevs + p[5];
209 __timezone = -zi_read32(p);
211 if (p[4] && !__tzname[1]) {
212 __tzname[1] = (char *)abbrevs + p[5];
213 dst_off = -zi_read32(p);
217 if (!__tzname[0]) __tzname[0] = __tzname[1];
218 if (!__tzname[0]) __tzname[0] = (char *)__utc;
220 __tzname[1] = __tzname[0];
221 dst_off = __timezone;
228 getname(std_name, &s);
229 __tzname[0] = std_name;
230 __timezone = getoff(&s);
231 getname(dst_name, &s);
232 __tzname[1] = dst_name;
235 if (*s == '+' || *s=='-' || *s-'0'<10U)
236 dst_off = getoff(&s);
238 dst_off = __timezone - 3600;
241 dst_off = __timezone;
244 if (*s == ',') s++, getrule(&s, r0);
245 if (*s == ',') s++, getrule(&s, r1);
248 /* Search zoneinfo rules to find the one that applies to the given time,
249 * and determine alternate opposite-DST-status rule that may be needed. */
251 static size_t scan_trans(long long t, int local, size_t *alt)
253 int scale = 3 - (trans == zi+44);
257 size_t a = 0, n = (index-trans)>>scale, m;
264 /* Binary search for 'most-recent rule before t'. */
267 x = zi_read32(trans + (m<<scale));
268 if (scale == 3) x = x<<32 | zi_read32(trans + (m<<scale) + 4);
270 if (local) off = (int32_t)zi_read32(types + 6 * index[m-1]);
271 if (t - off < (int64_t)x) {
279 /* First and last entry are special. First means to use lowest-index
280 * non-DST type. Last means to apply POSIX-style rule if available. */
281 n = (index-trans)>>scale;
282 if (a == n-1) return -1;
284 x = zi_read32(trans + (a<<scale));
285 if (scale == 3) x = x<<32 | zi_read32(trans + (a<<scale) + 4);
287 if (local) off = (int32_t)zi_read32(types + 6 * index[a-1]);
288 if (t - off < (int64_t)x) {
289 for (a=0; a<(abbrevs-types)/6; a++) {
290 if (types[6*a+4] != types[4]) break;
292 if (a == (abbrevs-types)/6) a = 0;
303 /* Try to find a neighboring opposite-DST-status rule. */
305 if (a && types[6*index[a-1]+4] != types[6*index[a]+4])
307 else if (a+1<n && types[6*index[a+1]+4] != types[6*index[a]+4])
316 static int days_in_month(int m, int is_leap)
318 if (m==2) return 28+is_leap;
319 else return 30+((0xad5>>(m-1))&1);
322 /* Convert a POSIX DST rule plus year to seconds since epoch. */
324 static long long rule_to_secs(const int *rule, int year)
327 long long t = __year_to_secs(year, &is_leap);
331 if (rule[0]=='J' && (x < 60 || !is_leap)) x--;
337 t += __month_to_secs(m-1, is_leap);
338 int wday = (int)((t + 4*86400) % (7*86400)) / 86400;
340 if (days < 0) days += 7;
341 if (n == 5 && days+28 >= days_in_month(m, is_leap)) n = 4;
342 t += 86400 * (days + 7*(n-1));
348 /* Determine the time zone in effect for a given time in seconds since the
349 * epoch. It can be given in local or universal time. The results will
350 * indicate whether DST is in effect at the queried time, and will give both
351 * the GMT offset for the active zone/DST rule and the opposite DST. This
352 * enables a caller to efficiently adjust for the case where an explicit
353 * DST specification mismatches what would be in effect at the time. */
355 void __secs_to_zone(long long t, int local, int *isdst, long *offset, long *oppoff, const char **zonename)
362 size_t alt, i = scan_trans(t, local, &alt);
364 *isdst = types[6*i+4];
365 *offset = (int32_t)zi_read32(types+6*i);
366 *zonename = (const char *)abbrevs + types[6*i+5];
367 if (oppoff) *oppoff = (int32_t)zi_read32(types+6*alt);
373 if (!__daylight) goto std;
375 /* FIXME: may be broken if DST changes right at year boundary?
376 * Also, this could be more efficient.*/
377 long long y = t / 31556952 + 70;
378 while (__year_to_secs(y, 0) > t) y--;
379 while (__year_to_secs(y+1, 0) < t) y++;
381 long long t0 = rule_to_secs(r0, y);
382 long long t1 = rule_to_secs(r1, y);
389 if (t >= t0 && t < t1) goto dst;
392 if (t >= t1 && t < t0) goto std;
397 *offset = -__timezone;
398 if (oppoff) *oppoff = -dst_off;
399 *zonename = __tzname[0];
405 if (oppoff) *oppoff = -__timezone;
406 *zonename = __tzname[1];
410 static void __tzset()
417 weak_alias(__tzset, tzset);
419 const char *__tm_to_tzname(const struct tm *tm)
421 const void *p = tm->__tm_zone;
424 if (p != __utc && p != __tzname[0] && p != __tzname[1] &&
425 (!zi || (uintptr_t)p-(uintptr_t)abbrevs >= abbrevs_end - abbrevs))