/* Time zone functions such as tzalloc and localtime_rz
Copyright 2015-2018 Free Software Foundation, Inc.
This program is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 3, or (at your option)
any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License along
with this program; if not, see <https://www.gnu.org/licenses/>. */
/* Written by Paul Eggert. */
/* Although this module is not thread-safe, any races should be fairly
rare and reasonably benign. For complete thread-safety, use a C
library with a working timezone_t type, so that this module is not
needed. */
#include <config.h>
#include <time.h>
#include <errno.h>
#include <limits.h>
#include <stdbool.h>
#include <stddef.h>
#include <stdlib.h>
#include <string.h>
#include "flexmember.h"
#include "time-internal.h"
#ifndef SIZE_MAX
# define SIZE_MAX ((size_t) -1)
#endif
/* The approximate size to use for small allocation requests. This is
the largest "small" request for the GNU C library malloc. */
enum { DEFAULT_MXFAST = 64 * sizeof (size_t) / 4 };
/* Minimum size of the ABBRS member of struct tm_zone. ABBRS is larger
only in the unlikely case where an abbreviation longer than this is
used. */
enum { ABBR_SIZE_MIN = DEFAULT_MXFAST - offsetof (struct tm_zone, abbrs) };
/* Magic cookie timezone_t value, for local time. It differs from
NULL and from all other timezone_t values. Only the address
matters; the pointer is never dereferenced. */
static timezone_t const local_tz = (timezone_t) 1;
#if HAVE_TM_ZONE || HAVE_TZNAME
/* Return true if the values A and B differ according to the rules for
tm_isdst: A and B differ if one is zero and the other positive. */
static bool
isdst_differ (int a, int b)
{
return !a != !b && 0 <= a && 0 <= b;
}
/* Return true if A and B are equal. */
static int
equal_tm (const struct tm *a, const struct tm *b)
{
return ! ((a->tm_sec ^ b->tm_sec)
| (a->tm_min ^ b->tm_min)
| (a->tm_hour ^ b->tm_hour)
| (a->tm_mday ^ b->tm_mday)
| (a->tm_mon ^ b->tm_mon)
| (a->tm_year ^ b->tm_year)
| isdst_differ (a->tm_isdst, b->tm_isdst));
}
#endif
/* Copy to ABBRS the abbreviation at ABBR with size ABBR_SIZE (this
includes its trailing null byte). Append an extra null byte to
mark the end of ABBRS. */
static void
extend_abbrs (char *abbrs, char const *abbr, size_t abbr_size)
{
memcpy (abbrs, abbr, abbr_size);
abbrs[abbr_size] = '\0';
}
/* Return a newly allocated time zone for NAME, or NULL on failure.
A null NAME stands for wall clock time (which is like unset TZ). */
timezone_t
tzalloc (char const *name)
{
size_t name_size = name ? strlen (name) + 1 : 0;
size_t abbr_size = name_size < ABBR_SIZE_MIN ? ABBR_SIZE_MIN : name_size + 1;
timezone_t tz = malloc (FLEXSIZEOF (struct tm_zone, abbrs, abbr_size));
if (tz)
{
tz->next = NULL;
#if HAVE_TZNAME && !HAVE_TM_ZONE
tz->tzname_copy[0] = tz->tzname_copy[1] = NULL;
#endif
tz->tz_is_set = !!name;
tz->abbrs[0] = '\0';
if (name)
extend_abbrs (tz->abbrs, name, name_size);
}
return tz;
}
/* Save into TZ any nontrivial time zone abbreviation used by TM, and
update *TM (if HAVE_TM_ZONE) or *TZ (if !HAVE_TM_ZONE &&
HAVE_TZNAME) if they use the abbreviation. Return true if
successful, false (setting errno) otherwise. */
static bool
save_abbr (timezone_t tz, struct tm *tm)
{
#if HAVE_TM_ZONE || HAVE_TZNAME
char const *zone = NULL;
char *zone_copy = (char *) "";
# if HAVE_TZNAME
int tzname_index = -1;
# endif
# if HAVE_TM_ZONE
zone = tm->tm_zone;
# endif
# if HAVE_TZNAME
if (! (zone && *zone) && 0 <= tm->tm_isdst)
{
tzname_index = tm->tm_isdst != 0;
zone = tzname[tzname_index];
}
# endif
/* No need to replace null zones, or zones within the struct tm. */
if (!zone || ((char *) tm <= zone && zone < (char *) (tm + 1)))
return true;
if (*zone)
{
zone_copy = tz->abbrs;
while (strcmp (zone_copy, zone) != 0)
{
if (! (*zone_copy || (zone_copy == tz->abbrs && tz->tz_is_set)))
{
size_t zone_size = strlen (zone) + 1;
size_t zone_used = zone_copy - tz->abbrs;
if (SIZE_MAX - zone_used < zone_size)
{
errno = ENOMEM;
return false;
}
if (zone_used + zone_size < ABBR_SIZE_MIN)
extend_abbrs (zone_copy, zone, zone_size);
else
{
tz = tz->next = tzalloc (zone);
if (!tz)
return false;
tz->tz_is_set = 0;
zone_copy = tz->abbrs;
}
break;
}
zone_copy += strlen (zone_copy) + 1;
if (!*zone_copy && tz->next)
{
tz = tz->next;
zone_copy = tz->abbrs;
}
}
}
/* Replace the zone name so that its lifetime matches that of TZ. */
# if HAVE_TM_ZONE
tm->tm_zone = zone_copy;
# else
if (0 <= tzname_index)
tz->tzname_copy[tzname_index] = zone_copy;
# endif
#endif
return true;
}
/* Free a time zone. */
void
tzfree (timezone_t tz)
{
if (tz != local_tz)
while (tz)
{
timezone_t next = tz->next;
free (tz);
tz = next;
}
}
/* Get and set the TZ environment variable. These functions can be
overridden by programs like Emacs that manage their own environment. */
#ifndef getenv_TZ
static char *
getenv_TZ (void)
{
return getenv ("TZ");
}
#endif
#ifndef setenv_TZ
static int
setenv_TZ (char const *tz)
{
return tz ? setenv ("TZ", tz, 1) : unsetenv ("TZ");
}
#endif
/* Change the environment to match the specified timezone_t value.
Return true if successful, false (setting errno) otherwise. */
static bool
change_env (timezone_t tz)
{
if (setenv_TZ (tz->tz_is_set ? tz->abbrs : NULL) != 0)
return false;
tzset ();
return true;
}
/* Temporarily set the time zone to TZ, which must not be null.
Return LOCAL_TZ if the time zone setting is already correct.
Otherwise return a newly allocated time zone representing the old
setting, or NULL (setting errno) on failure. */
static timezone_t
set_tz (timezone_t tz)
{
char *env_tz = getenv_TZ ();
if (env_tz
? tz->tz_is_set && strcmp (tz->abbrs, env_tz) == 0
: !tz->tz_is_set)
return local_tz;
else
{
timezone_t old_tz = tzalloc (env_tz);
if (!old_tz)
return old_tz;
if (! change_env (tz))
{
int saved_errno = errno;
tzfree (old_tz);
errno = saved_errno;
return NULL;
}
return old_tz;
}
}
/* Restore an old setting returned by set_tz. It must not be null.
Return true (preserving errno) if successful, false (setting errno)
otherwise. */
static bool
revert_tz (timezone_t tz)
{
if (tz == local_tz)
return true;
else
{
int saved_errno = errno;
bool ok = change_env (tz);
if (!ok)
saved_errno = errno;
tzfree (tz);
errno = saved_errno;
return ok;
}
}
/* Use time zone TZ to compute localtime_r (T, TM). */
struct tm *
localtime_rz (timezone_t tz, time_t const *t, struct tm *tm)
{
#ifdef HAVE_LOCALTIME_INFLOOP_BUG
/* The -67768038400665599 comes from:
https://lists.gnu.org/r/bug-gnulib/2017-07/msg00142.html
On affected platforms the greatest POSIX-compatible time_t value
that could return nonnull is 67768036191766798 (when
TZ="XXX24:59:59" it resolves to the year 2**31 - 1 + 1900, on
12-31 at 23:59:59), so test for that too while we're in the
neighborhood. */
if (! (-67768038400665599 <= *t && *t <= 67768036191766798))
{
errno = EOVERFLOW;
return NULL;
}
#endif
if (!tz)
return gmtime_r (t, tm);
else
{
timezone_t old_tz = set_tz (tz);
if (old_tz)
{
bool abbr_saved = localtime_r (t, tm) && save_abbr (tz, tm);
if (revert_tz (old_tz) && abbr_saved)
return tm;
}
return NULL;
}
}
/* Use time zone TZ to compute mktime (TM). */
time_t
mktime_z (timezone_t tz, struct tm *tm)
{
if (!tz)
return timegm (tm);
else
{
timezone_t old_tz = set_tz (tz);
if (old_tz)
{
time_t t = mktime (tm);
#if HAVE_TM_ZONE || HAVE_TZNAME
time_t badtime = -1;
struct tm tm_1;
if ((t != badtime
|| (localtime_r (&t, &tm_1) && equal_tm (tm, &tm_1)))
&& !save_abbr (tz, tm))
t = badtime;
#endif
if (revert_tz (old_tz))
return t;
}
return -1;
}
}