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 <sys/mman.h>
   7 #include "libc.h"
   8 #include "lock.h"
   9
  10 long  __timezone = 0;
  11 int   __daylight = 0;
  12 char *__tzname[2] = { 0, 0 };
  13
  14 weak_alias(__timezone, timezone);
  15 weak_alias(__daylight, daylight);
  16 weak_alias(__tzname, tzname);
  17
  18 static char std_name[TZNAME_MAX+1];
  19 static char dst_name[TZNAME_MAX+1];
  20 const char __utc[] = "UTC";
  21
  22 static int dst_off;
  23 static int r0[5], r1[5];
  24
  25 static const unsigned char *zi, *trans, *index, *types, *abbrevs, *abbrevs_end;
  26 static size_t map_size;
  27
  28 static char old_tz_buf[32];
  29 static char *old_tz = old_tz_buf;
  30 static size_t old_tz_size = sizeof old_tz_buf;
  31
  32 static volatile int lock[1];
  33
  34 static int getint(const char **p)
  35 {
  36         unsigned x;
  37         for (x=0; **p-'0'<10U; (*p)++) x = **p-'0' + 10*x;
  38         return x;
  39 }
  40
  41 static int getoff(const char **p)
  42 {
  43         int neg = 0;
  44         if (**p == '-') {
  45                 ++*p;
  46                 neg = 1;
  47         } else if (**p == '+') {
  48                 ++*p;
  49         }
  50         int off = 3600*getint(p);
  51         if (**p == ':') {
  52                 ++*p;
  53                 off += 60*getint(p);
  54                 if (**p == ':') {
  55                         ++*p;
  56                         off += getint(p);
  57                 }
  58         }
  59         return neg ? -off : off;
  60 }
  61
  62 static void getrule(const char **p, int rule[5])
  63 {
  64         int r = rule[0] = **p;
  65
  66         if (r!='M') {
  67                 if (r=='J') ++*p;
  68                 else rule[0] = 0;
  69                 rule[1] = getint(p);
  70         } else {
  71                 ++*p; rule[1] = getint(p);
  72                 ++*p; rule[2] = getint(p);
  73                 ++*p; rule[3] = getint(p);
  74         }
  75
  76         if (**p=='/') {
  77                 ++*p;
  78                 rule[4] = getoff(p);
  79         } else {
  80                 rule[4] = 7200;
  81         }
  82 }
  83
  84 static void getname(char *d, const char **p)
  85 {
  86         int i;
  87         if (**p == '<') {
  88                 ++*p;
  89                 for (i=0; (*p)[i]!='>' && i<TZNAME_MAX; i++)
  90                         d[i] = (*p)[i];
  91                 ++*p;
  92         } else {
  93                 for (i=0; ((*p)[i]|32)-'a'<26U && i<TZNAME_MAX; i++)
  94                         d[i] = (*p)[i];
  95         }
  96         *p += i;
  97         d[i] = 0;
  98 }
  99
 100 #define VEC(...) ((const unsigned char[]){__VA_ARGS__})
 101
 102 static uint32_t zi_read32(const unsigned char *z)
 103 {
 104         return (unsigned)z[0]<<24 | z[1]<<16 | z[2]<<8 | z[3];
 105 }
 106
 107 static size_t zi_dotprod(const unsigned char *z, const unsigned char *v, size_t n)
 108 {
 109         size_t y;
 110         uint32_t x;
 111         for (y=0; n; n--, z+=4, v++) {
 112                 x = zi_read32(z);
 113                 y += x * *v;
 114         }
 115         return y;
 116 }
 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 = __utc;
 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 = __utc, 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 = __utc;
 169         }
 170         if (map && (map_size < 44 || memcmp(map, "TZif", 4))) {
 171                 __munmap((void *)map, map_size);
 172                 map = 0;
 173                 s = __utc;
 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 *)__utc;
 211                         if (!__daylight) {
 212                                 __tzname[1] = __tzname[0];
 213                                 dst_off = __timezone;
 214                         }
 215                         return;
 216                 }
 217         }
 218
 219         if (!s) s = __utc;
 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 = __timezone;
 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 static 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 != __utc && 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 }