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 } 345