lib/time_rz.c

   1 /* Time zone functions such as tzalloc and localtime_rz
   2
   3    Copyright 2015-2018 Free Software Foundation, Inc.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 3, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License along
  16    with this program; if not, see <https://www.gnu.org/licenses/>.  */
  17
  18 /* Written by Paul Eggert.  */
  19
  20 /* Although this module is not thread-safe, any races should be fairly
  21    rare and reasonably benign.  For complete thread-safety, use a C
  22    library with a working timezone_t type, so that this module is not
  23    needed.  */
  24
  25 #include <config.h>
  26
  27 #include <time.h>
  28
  29 #include <errno.h>
  30 #include <limits.h>
  31 #include <stdbool.h>
  32 #include <stddef.h>
  33 #include <stdlib.h>
  34 #include <string.h>
  35
  36 #include "flexmember.h"
  37 #include "time-internal.h"
  38
  39 #ifndef SIZE_MAX
  40 # define SIZE_MAX ((size_t) -1)
  41 #endif
  42
  43 /* The approximate size to use for small allocation requests.  This is
  44    the largest "small" request for the GNU C library malloc.  */
  45 enum { DEFAULT_MXFAST = 64 * sizeof (size_t) / 4 };
  46
  47 /* Minimum size of the ABBRS member of struct tm_zone.  ABBRS is larger
  48    only in the unlikely case where an abbreviation longer than this is
  49    used.  */
  50 enum { ABBR_SIZE_MIN = DEFAULT_MXFAST - offsetof (struct tm_zone, abbrs) };
  51
  52 /* Magic cookie timezone_t value, for local time.  It differs from
  53    NULL and from all other timezone_t values.  Only the address
  54    matters; the pointer is never dereferenced.  */
  55 static timezone_t const local_tz = (timezone_t) 1;
  56
  57 #if HAVE_TM_ZONE || HAVE_TZNAME
  58
  59 /* Return true if the values A and B differ according to the rules for
  60    tm_isdst: A and B differ if one is zero and the other positive.  */
  61 static bool
  62 isdst_differ (int a, int b)
  63 {
  64   return !a != !b && 0 <= a && 0 <= b;
  65 }
  66
  67 /* Return true if A and B are equal.  */
  68 static int
  69 equal_tm (const struct tm *a, const struct tm *b)
  70 {
  71   return ! ((a->tm_sec ^ b->tm_sec)
  72             | (a->tm_min ^ b->tm_min)
  73             | (a->tm_hour ^ b->tm_hour)
  74             | (a->tm_mday ^ b->tm_mday)
  75             | (a->tm_mon ^ b->tm_mon)
  76             | (a->tm_year ^ b->tm_year)
  77             | isdst_differ (a->tm_isdst, b->tm_isdst));
  78 }
  79
  80 #endif
  81
  82 /* Copy to ABBRS the abbreviation at ABBR with size ABBR_SIZE (this
  83    includes its trailing null byte).  Append an extra null byte to
  84    mark the end of ABBRS.  */
  85 static void
  86 extend_abbrs (char *abbrs, char const *abbr, size_t abbr_size)
  87 {
  88   memcpy (abbrs, abbr, abbr_size);
  89   abbrs[abbr_size] = '\0';
  90 }
  91
  92 /* Return a newly allocated time zone for NAME, or NULL on failure.
  93    A null NAME stands for wall clock time (which is like unset TZ).  */
  94 timezone_t
  95 tzalloc (char const *name)
  96 {
  97   size_t name_size = name ? strlen (name) + 1 : 0;
  98   size_t abbr_size = name_size < ABBR_SIZE_MIN ? ABBR_SIZE_MIN : name_size + 1;
  99   timezone_t tz = malloc (FLEXSIZEOF (struct tm_zone, abbrs, abbr_size));
 100   if (tz)
 101     {
 102       tz->next = NULL;
 103 #if HAVE_TZNAME && !HAVE_TM_ZONE
 104       tz->tzname_copy[0] = tz->tzname_copy[1] = NULL;
 105 #endif
 106       tz->tz_is_set = !!name;
 107       tz->abbrs[0] = '\0';
 108       if (name)
 109         extend_abbrs (tz->abbrs, name, name_size);
 110     }
 111   return tz;
 112 }
 113
 114 /* Save into TZ any nontrivial time zone abbreviation used by TM, and
 115    update *TM (if HAVE_TM_ZONE) or *TZ (if !HAVE_TM_ZONE &&
 116    HAVE_TZNAME) if they use the abbreviation.  Return true if
 117    successful, false (setting errno) otherwise.  */
 118 static bool
 119 save_abbr (timezone_t tz, struct tm *tm)
 120 {
 121 #if HAVE_TM_ZONE || HAVE_TZNAME
 122   char const *zone = NULL;
 123   char *zone_copy = (char *) "";
 124
 125 # if HAVE_TZNAME
 126   int tzname_index = -1;
 127 # endif
 128
 129 # if HAVE_TM_ZONE
 130   zone = tm->tm_zone;
 131 # endif
 132
 133 # if HAVE_TZNAME
 134   if (! (zone && *zone) && 0 <= tm->tm_isdst)
 135     {
 136       tzname_index = tm->tm_isdst != 0;
 137       zone = tzname[tzname_index];
 138     }
 139 # endif
 140
 141   /* No need to replace null zones, or zones within the struct tm.  */
 142   if (!zone || ((char *) tm <= zone && zone < (char *) (tm + 1)))
 143     return true;
 144
 145   if (*zone)
 146     {
 147       zone_copy = tz->abbrs;
 148
 149       while (strcmp (zone_copy, zone) != 0)
 150         {
 151           if (! (*zone_copy || (zone_copy == tz->abbrs && tz->tz_is_set)))
 152             {
 153               size_t zone_size = strlen (zone) + 1;
 154               size_t zone_used = zone_copy - tz->abbrs;
 155               if (SIZE_MAX - zone_used < zone_size)
 156                 {
 157                   errno = ENOMEM;
 158                   return false;
 159                 }
 160               if (zone_used + zone_size < ABBR_SIZE_MIN)
 161                 extend_abbrs (zone_copy, zone, zone_size);
 162               else
 163                 {
 164                   tz = tz->next = tzalloc (zone);
 165                   if (!tz)
 166                     return false;
 167                   tz->tz_is_set = 0;
 168                   zone_copy = tz->abbrs;
 169                 }
 170               break;
 171             }
 172
 173           zone_copy += strlen (zone_copy) + 1;
 174           if (!*zone_copy && tz->next)
 175             {
 176               tz = tz->next;
 177               zone_copy = tz->abbrs;
 178             }
 179         }
 180     }
 181
 182   /* Replace the zone name so that its lifetime matches that of TZ.  */
 183 # if HAVE_TM_ZONE
 184   tm->tm_zone = zone_copy;
 185 # else
 186   if (0 <= tzname_index)
 187     tz->tzname_copy[tzname_index] = zone_copy;
 188 # endif
 189 #endif
 190
 191   return true;
 192 }
 193
 194 /* Free a time zone.  */
 195 void
 196 tzfree (timezone_t tz)
 197 {
 198   if (tz != local_tz)
 199     while (tz)
 200       {
 201         timezone_t next = tz->next;
 202         free (tz);
 203         tz = next;
 204       }
 205 }
 206
 207 /* Get and set the TZ environment variable.  These functions can be
 208    overridden by programs like Emacs that manage their own environment.  */
 209
 210 #ifndef getenv_TZ
 211 static char *
 212 getenv_TZ (void)
 213 {
 214   return getenv ("TZ");
 215 }
 216 #endif
 217
 218 #ifndef setenv_TZ
 219 static int
 220 setenv_TZ (char const *tz)
 221 {
 222   return tz ? setenv ("TZ", tz, 1) : unsetenv ("TZ");
 223 }
 224 #endif
 225
 226 /* Change the environment to match the specified timezone_t value.
 227    Return true if successful, false (setting errno) otherwise.  */
 228 static bool
 229 change_env (timezone_t tz)
 230 {
 231   if (setenv_TZ (tz->tz_is_set ? tz->abbrs : NULL) != 0)
 232     return false;
 233   tzset ();
 234   return true;
 235 }
 236
 237 /* Temporarily set the time zone to TZ, which must not be null.
 238    Return LOCAL_TZ if the time zone setting is already correct.
 239    Otherwise return a newly allocated time zone representing the old
 240    setting, or NULL (setting errno) on failure.  */
 241 static timezone_t
 242 set_tz (timezone_t tz)
 243 {
 244   char *env_tz = getenv_TZ ();
 245   if (env_tz
 246       ? tz->tz_is_set && strcmp (tz->abbrs, env_tz) == 0
 247       : !tz->tz_is_set)
 248     return local_tz;
 249   else
 250     {
 251       timezone_t old_tz = tzalloc (env_tz);
 252       if (!old_tz)
 253         return old_tz;
 254       if (! change_env (tz))
 255         {
 256           int saved_errno = errno;
 257           tzfree (old_tz);
 258           errno = saved_errno;
 259           return NULL;
 260         }
 261       return old_tz;
 262     }
 263 }
 264
 265 /* Restore an old setting returned by set_tz.  It must not be null.
 266    Return true (preserving errno) if successful, false (setting errno)
 267    otherwise.  */
 268 static bool
 269 revert_tz (timezone_t tz)
 270 {
 271   if (tz == local_tz)
 272     return true;
 273   else
 274     {
 275       int saved_errno = errno;
 276       bool ok = change_env (tz);
 277       if (!ok)
 278         saved_errno = errno;
 279       tzfree (tz);
 280       errno = saved_errno;
 281       return ok;
 282     }
 283 }
 284
 285 /* Use time zone TZ to compute localtime_r (T, TM).  */
 286 struct tm *
 287 localtime_rz (timezone_t tz, time_t const *t, struct tm *tm)
 288 {
 289 #ifdef HAVE_LOCALTIME_INFLOOP_BUG
 290   /* The -67768038400665599 comes from:
 291      https://lists.gnu.org/r/bug-gnulib/2017-07/msg00142.html
 292      On affected platforms the greatest POSIX-compatible time_t value
 293      that could return nonnull is 67768036191766798 (when
 294      TZ="XXX24:59:59" it resolves to the year 2**31 - 1 + 1900, on
 295      12-31 at 23:59:59), so test for that too while we're in the
 296      neighborhood.  */
 297   if (! (-67768038400665599 <= *t && *t <= 67768036191766798))
 298     {
 299       errno = EOVERFLOW;
 300       return NULL;
 301     }
 302 #endif
 303
 304   if (!tz)
 305     return gmtime_r (t, tm);
 306   else
 307     {
 308       timezone_t old_tz = set_tz (tz);
 309       if (old_tz)
 310         {
 311           bool abbr_saved = localtime_r (t, tm) && save_abbr (tz, tm);
 312           if (revert_tz (old_tz) && abbr_saved)
 313             return tm;
 314         }
 315       return NULL;
 316     }
 317 }
 318
 319 /* Use time zone TZ to compute mktime (TM).  */
 320 time_t
 321 mktime_z (timezone_t tz, struct tm *tm)
 322 {
 323   if (!tz)
 324     return timegm (tm);
 325   else
 326     {
 327       timezone_t old_tz = set_tz (tz);
 328       if (old_tz)
 329         {
 330           time_t t = mktime (tm);
 331 #if HAVE_TM_ZONE || HAVE_TZNAME
 332           time_t badtime = -1;
 333           struct tm tm_1;
 334           if ((t != badtime
 335                || (localtime_r (&t, &tm_1) && equal_tm (tm, &tm_1)))
 336               && !save_abbr (tz, tm))
 337             t = badtime;
 338 #endif
 339           if (revert_tz (old_tz))
 340             return t;
 341         }
 342       return -1;
 343     }
 344 }