do not try to interpret implementation specific strings as tz definition
[musl] / src / time / __tz.c
1 #include "time_impl.h"
2 #include <stdint.h>
3 #include <limits.h>
4 #include <stdlib.h>
5 #include <string.h>
6 #include "libc.h"
7
8 long  __timezone = 0;
9 int   __daylight = 0;
10 char *__tzname[2] = { 0, 0 };
11
12 weak_alias(__timezone, timezone);
13 weak_alias(__daylight, daylight);
14 weak_alias(__tzname, tzname);
15
16 static char std_name[TZNAME_MAX+1];
17 static char dst_name[TZNAME_MAX+1];
18 const char __gmt[] = "GMT";
19
20 static int dst_off;
21 static int r0[5], r1[5];
22
23 static const unsigned char *zi, *trans, *index, *types, *abbrevs, *abbrevs_end;
24 static size_t map_size;
25
26 static char old_tz_buf[32];
27 static char *old_tz = old_tz_buf;
28 static size_t old_tz_size = sizeof old_tz_buf;
29
30 static int lock[2];
31
32 static int getint(const char **p)
33 {
34         unsigned x;
35         for (x=0; **p-'0'<10U; (*p)++) x = **p-'0' + 10*x;
36         return x;
37 }
38
39 static int getsigned(const char **p)
40 {
41         if (**p == '-') {
42                 ++*p;
43                 return -getint(p);
44         }
45         if (**p == '+') ++*p;
46         return getint(p);
47 }
48
49 static int getoff(const char **p)
50 {
51         int off = 3600*getsigned(p);
52         if (**p == ':') {
53                 ++*p;
54                 off += 60*getint(p);
55                 if (**p == ':') {
56                         ++*p;
57                         off += getint(p);
58                 }
59         }
60         return off;
61 }
62
63 static void getrule(const char **p, int rule[5])
64 {
65         int r = rule[0] = **p;
66
67         if (r!='M') {
68                 if (r=='J') ++*p;
69                 else rule[0] = 0;
70                 rule[1] = getint(p);
71         } else {
72                 ++*p; rule[1] = getint(p);
73                 ++*p; rule[2] = getint(p);
74                 ++*p; rule[3] = getint(p);
75         }
76
77         if (**p=='/') {
78                 ++*p;
79                 rule[4] = getoff(p);
80         } else {
81                 rule[4] = 7200;
82         }
83 }
84
85 static void getname(char *d, const char **p)
86 {
87         int i;
88         if (**p == '<') {
89                 ++*p;
90                 for (i=0; **p!='>' && i<TZNAME_MAX; i++)
91                         d[i] = (*p)[i];
92                 ++*p;
93         } else {
94                 for (i=0; ((*p)[i]|32)-'a'<26U && i<TZNAME_MAX; i++)
95                         d[i] = (*p)[i];
96         }
97         *p += i;
98         d[i] = 0;
99 }
100
101 #define VEC(...) ((const unsigned char[]){__VA_ARGS__})
102
103 static uint32_t zi_read32(const unsigned char *z)
104 {
105         return (unsigned)z[0]<<24 | z[1]<<16 | z[2]<<8 | z[3];
106 }
107
108 static size_t zi_dotprod(const unsigned char *z, const unsigned char *v, size_t n)
109 {
110         size_t y;
111         uint32_t x;
112         for (y=0; n; n--, z+=4, v++) {
113                 x = zi_read32(z);
114                 y += x * *v;
115         }
116         return y;
117 }
118
119 int __munmap(void *, size_t);
120
121 static void do_tzset()
122 {
123         char buf[NAME_MAX+25], *pathname=buf+24;
124         const char *try, *s, *p;
125         const unsigned char *map = 0;
126         size_t i;
127         static const char search[] =
128                 "/usr/share/zoneinfo/\0/share/zoneinfo/\0/etc/zoneinfo/\0";
129
130         s = getenv("TZ");
131         if (!s || !*s) s = __gmt;
132
133         if (old_tz && !strcmp(s, old_tz)) return;
134
135         if (zi) __munmap((void *)zi, map_size);
136
137         /* Cache the old value of TZ to check if it has changed. Avoid
138          * free so as not to pull it into static programs. Growth
139          * strategy makes it so free would have minimal benefit anyway. */
140         i = strlen(s);
141         if (i > PATH_MAX+1) s = __gmt, i = 3;
142         if (i >= old_tz_size) {
143                 old_tz_size *= 2;
144                 if (i >= old_tz_size) old_tz_size = i+1;
145                 if (old_tz_size > PATH_MAX+2) old_tz_size = PATH_MAX+2;
146                 old_tz = malloc(old_tz_size);
147         }
148         if (old_tz) memcpy(old_tz, s, i+1);
149
150         /* Non-suid can use an absolute tzfile pathname or a relative
151          * pathame beginning with "."; in secure mode, only the
152          * standard path will be searched. */
153         if (*s == ':' || ((p=strchr(s, '/')) && !memchr(s, ',', p-s))) {
154                 if (*s == ':') s++;
155                 if (*s == '/' || *s == '.') {
156                         if (!libc.secure) map = __map_file(s, &map_size);
157                 } else {
158                         size_t l = strlen(s);
159                         if (l <= NAME_MAX && !strchr(s, '.')) {
160                                 memcpy(pathname, s, l+1);
161                                 pathname[l] = 0;
162                                 for (try=search; !map && *try; try+=l+1) {
163                                         l = strlen(try);
164                                         memcpy(pathname-l, try, l);
165                                         map = __map_file(pathname-l, &map_size);
166                                 }
167                         }
168                 }
169                 if (!map) s = __gmt;
170         }
171
172         zi = map;
173         if (map) {
174                 int scale = 2;
175                 if (sizeof(time_t) > 4 && map[4]=='2') {
176                         size_t skip = zi_dotprod(zi+20, VEC(1,1,8,5,6,1), 6);
177                         trans = zi+skip+44+44;
178                         scale++;
179                 } else {
180                         trans = zi+44;
181                 }
182                 index = trans + (zi_read32(trans-12) << scale);
183                 types = index + zi_read32(trans-12);
184                 abbrevs = types + 6*zi_read32(trans-8);
185                 abbrevs_end = abbrevs + zi_read32(trans-4);
186                 if (zi[map_size-1] == '\n') {
187                         for (s = (const char *)zi+map_size-2; *s!='\n'; s--);
188                         s++;
189                 } else {
190                         const unsigned char *p;
191                         __tzname[0] = __tzname[1] = 0;
192                         __daylight = __timezone = dst_off = 0;
193                         for (i=0; i<5; i++) r0[i] = r1[i] = 0;
194                         for (p=types; p<abbrevs; p+=6) {
195                                 if (!p[4] && !__tzname[0]) {
196                                         __tzname[0] = (char *)abbrevs + p[5];
197                                         __timezone = -zi_read32(p);
198                                 }
199                                 if (p[4] && !__tzname[1]) {
200                                         __tzname[1] = (char *)abbrevs + p[5];
201                                         dst_off = -zi_read32(p);
202                                         __daylight = 1;
203                                 }
204                         }
205                         if (!__tzname[0]) __tzname[0] = __tzname[1];
206                         if (!__tzname[0]) __tzname[0] = (char *)__gmt;
207                         if (!__daylight) {
208                                 __tzname[1] = __tzname[0];
209                                 dst_off = __timezone;
210                         }
211                         return;
212                 }
213         }
214
215         if (!s) s = __gmt;
216         getname(std_name, &s);
217         __tzname[0] = std_name;
218         __timezone = getoff(&s);
219         getname(dst_name, &s);
220         __tzname[1] = dst_name;
221         if (dst_name[0]) {
222                 __daylight = 1;
223                 if (*s == '+' || *s=='-' || *s-'0'<10U)
224                         dst_off = getoff(&s);
225                 else
226                         dst_off = __timezone - 3600;
227         } else {
228                 __daylight = 0;
229                 dst_off = 0;
230         }
231
232         if (*s == ',') s++, getrule(&s, r0);
233         if (*s == ',') s++, getrule(&s, r1);
234 }
235
236 /* Search zoneinfo rules to find the one that applies to the given time,
237  * and determine alternate opposite-DST-status rule that may be needed. */
238
239 static size_t scan_trans(long long t, int local, size_t *alt)
240 {
241         int scale = 3 - (trans == zi+44);
242         uint64_t x;
243         int off = 0;
244
245         size_t a = 0, n = (index-trans)>>scale, m;
246
247         if (!n) {
248                 if (alt) *alt = 0;
249                 return 0;
250         }
251
252         /* Binary search for 'most-recent rule before t'. */
253         while (n > 1) {
254                 m = a + n/2;
255                 x = zi_read32(trans + (m<<scale));
256                 if (scale == 3) x = x<<32 | zi_read32(trans + (m<<scale) + 4);
257                 else x = (int32_t)x;
258                 if (local) off = (int32_t)zi_read32(types + 6 * index[m-1]);
259                 if (t - off < (int64_t)x) {
260                         n /= 2;
261                 } else {
262                         a = m;
263                         n -= n/2;
264                 }
265         }
266
267         /* First and last entry are special. First means to use lowest-index
268          * non-DST type. Last means to apply POSIX-style rule if available. */
269         n = (index-trans)>>scale;
270         if (a == n-1) return -1;
271         if (a == 0) {
272                 x = zi_read32(trans + (a<<scale));
273                 if (scale == 3) x = x<<32 | zi_read32(trans + (a<<scale) + 4);
274                 else x = (int32_t)x;
275                 if (local) off = (int32_t)zi_read32(types + 6 * index[a-1]);
276                 if (t - off < (int64_t)x) {
277                         for (a=0; a<(abbrevs-types)/6; a++) {
278                                 if (types[6*a+4] != types[4]) break;
279                         }
280                         if (a == (abbrevs-types)/6) a = 0;
281                         if (types[6*a+4]) {
282                                 *alt = a;
283                                 return 0;
284                         } else {
285                                 *alt = 0;
286                                 return a;
287                         }
288                 }
289         }
290
291         /* Try to find a neighboring opposite-DST-status rule. */
292         if (alt) {
293                 if (a && types[6*index[a-1]+4] != types[6*index[a]+4])
294                         *alt = index[a-1];
295                 else if (a+1<n && types[6*index[a+1]+4] != types[6*index[a]+4])
296                         *alt = index[a+1];
297                 else
298                         *alt = index[a];
299         }
300
301         return index[a];
302 }
303
304 static int days_in_month(int m, int is_leap)
305 {
306         if (m==2) return 28+is_leap;
307         else return 30+((0xad5>>(m-1))&1);
308 }
309
310 /* Convert a POSIX DST rule plus year to seconds since epoch. */
311
312 static long long rule_to_secs(const int *rule, int year)
313 {
314         int is_leap;
315         long long t = __year_to_secs(year, &is_leap);
316         int x, m, n, d;
317         if (rule[0]!='M') {
318                 x = rule[1];
319                 if (rule[0]=='J' && (x < 60 || !is_leap)) x--;
320                 t += 86400 * x;
321         } else {
322                 m = rule[1];
323                 n = rule[2];
324                 d = rule[3];
325                 t += __month_to_secs(m-1, is_leap);
326                 int wday = (int)((t + 4*86400) % (7*86400)) / 86400;
327                 int days = d - wday;
328                 if (days < 0) days += 7;
329                 if (n == 5 && days+28 >= days_in_month(m, is_leap)) n = 4;
330                 t += 86400 * (days + 7*(n-1));
331         }
332         t += rule[4];
333         return t;
334 }
335
336 /* Determine the time zone in effect for a given time in seconds since the
337  * epoch. It can be given in local or universal time. The results will
338  * indicate whether DST is in effect at the queried time, and will give both
339  * the GMT offset for the active zone/DST rule and the opposite DST. This
340  * enables a caller to efficiently adjust for the case where an explicit
341  * DST specification mismatches what would be in effect at the time. */
342
343 void __secs_to_zone(long long t, int local, int *isdst, long *offset, long *oppoff, const char **zonename)
344 {
345         LOCK(lock);
346
347         do_tzset();
348
349         if (zi) {
350                 size_t alt, i = scan_trans(t, local, &alt);
351                 if (i != -1) {
352                         *isdst = types[6*i+4];
353                         *offset = -(int32_t)zi_read32(types+6*i);
354                         *zonename = (const char *)abbrevs + types[6*i+5];
355                         if (oppoff) *oppoff = -(int32_t)zi_read32(types+6*alt);
356                         UNLOCK(lock);
357                         return;
358                 }
359         }
360
361         if (!__daylight) goto std;
362
363         /* FIXME: may be broken if DST changes right at year boundary?
364          * Also, this could be more efficient.*/
365         long long y = t / 31556952 + 70;
366         while (__year_to_secs(y, 0) > t) y--;
367         while (__year_to_secs(y+1, 0) < t) y++;
368
369         long long t0 = rule_to_secs(r0, y);
370         long long t1 = rule_to_secs(r1, y);
371
372         if (t0 < t1) {
373                 if (!local) {
374                         t0 += __timezone;
375                         t1 += dst_off;
376                 }
377                 if (t >= t0 && t < t1) goto dst;
378                 goto std;
379         } else {
380                 if (!local) {
381                         t1 += __timezone;
382                         t0 += dst_off;
383                 }
384                 if (t >= t1 && t < t0) goto std;
385                 goto dst;
386         }
387 std:
388         *isdst = 0;
389         *offset = __timezone;
390         if (oppoff) *oppoff = dst_off;
391         *zonename = __tzname[0];
392         UNLOCK(lock);
393         return;
394 dst:
395         *isdst = 1;
396         *offset = dst_off;
397         if (oppoff) *oppoff = __timezone;
398         *zonename = __tzname[1];
399         UNLOCK(lock);
400 }
401
402 void __tzset()
403 {
404         LOCK(lock);
405         do_tzset();
406         UNLOCK(lock);
407 }
408
409 weak_alias(__tzset, tzset);
410
411 const char *__tm_to_tzname(const struct tm *tm)
412 {
413         const void *p = tm->__tm_zone;
414         LOCK(lock);
415         do_tzset();
416         if (p != __gmt && p != __tzname[0] && p != __tzname[1] &&
417             (!zi || (uintptr_t)p-(uintptr_t)abbrevs >= abbrevs_end - abbrevs))
418                 p = "";
419         UNLOCK(lock);
420         return p;
421 }