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