lib/time_rz.c

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