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
isdst_differ(int a,int b)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
equal_tm(const struct tm * a,const struct tm * b)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
extend_abbrs(char * abbrs,char const * abbr,size_t abbr_size)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
tzalloc(char const * name)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
save_abbr(timezone_t tz,struct tm * tm)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
tzfree(timezone_t tz)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 *
getenv_TZ(void)212 getenv_TZ (void)
213 {
214   return getenv ("TZ");
215 }
216 #endif
217 
218 #ifndef setenv_TZ
219 static int
setenv_TZ(char const * tz)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
change_env(timezone_t tz)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
set_tz(timezone_t tz)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
revert_tz(timezone_t tz)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 *
localtime_rz(timezone_t tz,time_t const * t,struct tm * 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
mktime_z(timezone_t tz,struct tm * tm)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