HALF ECHO LEARN / REFERENCE COLLECTION

v262.2

src/basic/time-util.c

63,018 bytesGit mode 100644Download original fileLGPL-2.1-or-later

Git blob: 44c53067411741027580f465c9873e673db03028

Lines 1–1000 of 1,968

/* SPDX-License-Identifier: LGPL-2.1-or-later */
 
#include <stdlib.h>
#include <sys/timerfd.h>
#include <threads.h>
#include <unistd.h>
 
#include "alloc-util.h"
#include "env-util.h"
#include "errno-util.h"
#include "extract-word.h"
#include "hexdecoct.h"          /* IWYU pragma: keep */
#include "fd-util.h"
#include "fileio.h"
#include "fs-util.h"
#include "io-util.h"
#include "log.h"
#include "parse-util.h"
#include "path-util.h"
#include "stat-util.h"
#include "stdio-util.h"
#include "string-table.h"
#include "string-util.h"
#include "strv.h"
#include "time-util.h"
 
static clockid_t map_clock_id(clockid_t c) {
 
        /* Some more exotic archs (s390, ppc, …) lack the "ALARM" flavour of the clocks. Thus,
         * clock_gettime() will fail for them. Since they are essentially the same as their non-ALARM
         * pendants (their only difference is when timers are set on them), let's just map them
         * accordingly. This way, we can get the correct time even on those archs. */
 
        switch (c) {
 
        case CLOCK_BOOTTIME_ALARM:
                return CLOCK_BOOTTIME;
 
        case CLOCK_REALTIME_ALARM:
                return CLOCK_REALTIME;
 
        default:
                return c;
        }
}
 
usec_t now(clockid_t clock_id) {
        struct timespec ts;
 
        assert_se(clock_gettime(map_clock_id(clock_id), &ts) == 0);
 
        usec_t n = timespec_load(&ts);
 
        /* We use both 0 and USEC_INFINITY as niche values. If the current time collides with either, things are
         * really weird and really broken. Let's not allow this to go through, it would break too many of our
         * assumptions in code. */
        assert(n > 0);
        assert(n < USEC_INFINITY);
 
        return n;
}
 
nsec_t now_nsec(clockid_t clock_id) {
        struct timespec ts;
 
        assert_se(clock_gettime(map_clock_id(clock_id), &ts) == 0);
 
        nsec_t n = timespec_load_nsec(&ts);
 
        assert(n > 0);
        assert(n < NSEC_INFINITY);
 
        return n;
}
 
dual_timestamp* dual_timestamp_now(dual_timestamp *ts) {
        assert(ts);
 
        ts->realtime = now(CLOCK_REALTIME);
        ts->monotonic = now(CLOCK_MONOTONIC);
 
        return ts;
}
 
triple_timestamp* triple_timestamp_now(triple_timestamp *ts) {
        assert(ts);
 
        ts->realtime = now(CLOCK_REALTIME);
        ts->monotonic = now(CLOCK_MONOTONIC);
        ts->boottime = now(CLOCK_BOOTTIME);
 
        return ts;
}
 
usec_t map_clock_usec_raw(usec_t from, usec_t from_base, usec_t to_base) {
 
        /* Maps the time 'from' between two clocks, based on a common reference point where the first clock
         * is at 'from_base' and the second clock at 'to_base'. Basically calculates:
         *
         *         from - from_base + to_base
         *
         * But takes care of overflows/underflows and avoids signed operations. */
 
        if (from >= from_base) { /* In the future */
                usec_t delta = from - from_base;
 
                if (to_base >= USEC_INFINITY - delta) /* overflow? */
                        return USEC_INFINITY;
 
                return to_base + delta;
 
        } else { /* In the past */
                usec_t delta = from_base - from;
 
                if (to_base <= delta) /* underflow? */
                        return 0;
 
                return to_base - delta;
        }
}
 
usec_t map_clock_usec(usec_t from, clockid_t from_clock, clockid_t to_clock) {
 
        /* Try to avoid any inaccuracy needlessly added in case we convert from effectively the same clock
         * onto itself */
        if (map_clock_id(from_clock) == map_clock_id(to_clock))
                return from;
 
        /* Keep infinity as is */
        if (from == USEC_INFINITY)
                return from;
 
        return map_clock_usec_raw(from, now(from_clock), now(to_clock));
}
 
dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
        assert(ts);
 
        if (!timestamp_is_set(u)) {
                ts->realtime = ts->monotonic = u;
                return ts;
        }
 
        ts->realtime = u;
        ts->monotonic = map_clock_usec(u, CLOCK_REALTIME, CLOCK_MONOTONIC);
        return ts;
}
 
triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u) {
        usec_t nowr;
 
        assert(ts);
 
        if (!timestamp_is_set(u)) {
                ts->realtime = ts->monotonic = ts->boottime = u;
                return ts;
        }
 
        nowr = now(CLOCK_REALTIME);
 
        ts->realtime = u;
        ts->monotonic = map_clock_usec_raw(u, nowr, now(CLOCK_MONOTONIC));
        ts->boottime = map_clock_usec_raw(u, nowr, now(CLOCK_BOOTTIME));
 
        return ts;
}
 
triple_timestamp* triple_timestamp_from_boottime(triple_timestamp *ts, usec_t u) {
        usec_t nowb;
 
        assert(ts);
 
        if (u == USEC_INFINITY) {
                ts->realtime = ts->monotonic = ts->boottime = u;
                return ts;
        }
 
        nowb = now(CLOCK_BOOTTIME);
 
        ts->boottime = u;
        ts->monotonic = map_clock_usec_raw(u, nowb, now(CLOCK_MONOTONIC));
        ts->realtime = map_clock_usec_raw(u, nowb, now(CLOCK_REALTIME));
 
        return ts;
}
 
dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u) {
        assert(ts);
 
        if (u == USEC_INFINITY) {
                ts->realtime = ts->monotonic = USEC_INFINITY;
                return ts;
        }
 
        ts->monotonic = u;
        ts->realtime = map_clock_usec(u, CLOCK_MONOTONIC, CLOCK_REALTIME);
        return ts;
}
 
dual_timestamp* dual_timestamp_from_boottime(dual_timestamp *ts, usec_t u) {
        usec_t nowm;
 
        assert(ts);
 
        if (u == USEC_INFINITY) {
                ts->realtime = ts->monotonic = USEC_INFINITY;
                return ts;
        }
 
        nowm = now(CLOCK_BOOTTIME);
        ts->monotonic = map_clock_usec_raw(u, nowm, now(CLOCK_MONOTONIC));
        ts->realtime = map_clock_usec_raw(u, nowm, now(CLOCK_REALTIME));
        return ts;
}
 
usec_t triple_timestamp_by_clock(triple_timestamp *ts, clockid_t clock) {
        assert(ts);
 
        switch (clock) {
 
        case CLOCK_REALTIME:
        case CLOCK_REALTIME_ALARM:
                return ts->realtime;
 
        case CLOCK_MONOTONIC:
                return ts->monotonic;
 
        case CLOCK_BOOTTIME:
        case CLOCK_BOOTTIME_ALARM:
                return ts->boottime;
 
        default:
                return USEC_INFINITY;
        }
}
 
usec_t timespec_load(const struct timespec *ts) {
        assert(ts);
 
        if (ts->tv_sec < 0 || ts->tv_nsec < 0)
                return USEC_INFINITY;
 
        if ((usec_t) ts->tv_sec > (UINT64_MAX - (ts->tv_nsec / NSEC_PER_USEC)) / USEC_PER_SEC)
                return USEC_INFINITY;
 
        return
                (usec_t) ts->tv_sec * USEC_PER_SEC +
                (usec_t) ts->tv_nsec / NSEC_PER_USEC;
}
 
nsec_t timespec_load_nsec(const struct timespec *ts) {
        assert(ts);
 
        if (ts->tv_sec < 0 || ts->tv_nsec < 0)
                return NSEC_INFINITY;
 
        if ((nsec_t) ts->tv_sec >= (UINT64_MAX - ts->tv_nsec) / NSEC_PER_SEC)
                return NSEC_INFINITY;
 
        return (nsec_t) ts->tv_sec * NSEC_PER_SEC + (nsec_t) ts->tv_nsec;
}
 
struct timespec *timespec_store(struct timespec *ts, usec_t u) {
        assert(ts);
 
        if (u == USEC_INFINITY ||
            u / USEC_PER_SEC >= TIME_T_MAX) {
                ts->tv_sec = (time_t) -1;
                ts->tv_nsec = -1L;
                return ts;
        }
 
        ts->tv_sec = (time_t) (u / USEC_PER_SEC);
        ts->tv_nsec = (long) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
 
        return ts;
}
 
struct timespec *timespec_store_nsec(struct timespec *ts, nsec_t n) {
        assert(ts);
 
        if (n == NSEC_INFINITY ||
            n / NSEC_PER_SEC >= TIME_T_MAX) {
                ts->tv_sec = (time_t) -1;
                ts->tv_nsec = -1L;
                return ts;
        }
 
        ts->tv_sec = (time_t) (n / NSEC_PER_SEC);
        ts->tv_nsec = (long) (n % NSEC_PER_SEC);
 
        return ts;
}
 
usec_t timeval_load(const struct timeval *tv) {
        assert(tv);
 
        if (tv->tv_sec < 0 || tv->tv_usec < 0)
                return USEC_INFINITY;
 
        if ((usec_t) tv->tv_sec > (UINT64_MAX - tv->tv_usec) / USEC_PER_SEC)
                return USEC_INFINITY;
 
        return
                (usec_t) tv->tv_sec * USEC_PER_SEC +
                (usec_t) tv->tv_usec;
}
 
struct timeval *timeval_store(struct timeval *tv, usec_t u) {
        assert(tv);
 
        if (u == USEC_INFINITY ||
            u / USEC_PER_SEC > TIME_T_MAX) {
                tv->tv_sec = (time_t) -1;
                tv->tv_usec = (suseconds_t) -1;
        } else {
                tv->tv_sec = (time_t) (u / USEC_PER_SEC);
                tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
        }
 
        return tv;
}
 
/* Returns the abbreviated English weekday name for wd in Mon=0 … Sun=6 order.
 * We use non-localized (English) form so that timestamps can be parsed with
 * parse_timestamp() and always read the same regardless of locale. */
static const char *const weekday_table[_WEEKDAY_MAX] = {
        [WEEKDAY_MON] = "Mon",
        [WEEKDAY_TUE] = "Tue",
        [WEEKDAY_WED] = "Wed",
        [WEEKDAY_THU] = "Thu",
        [WEEKDAY_FRI] = "Fri",
        [WEEKDAY_SAT] = "Sat",
        [WEEKDAY_SUN] = "Sun",
};
 
DEFINE_STRING_TABLE_LOOKUP_TO_STRING(weekday, int);
 
char* format_timestamp_style(
                char *buf,
                size_t l,
                usec_t t,
                TimestampStyle style) {
        struct tm tm;
        bool utc, us;
        size_t n;
 
        assert(buf);
        assert(style >= 0);
        assert(style < _TIMESTAMP_STYLE_MAX);
 
        if (!timestamp_is_set(t))
                return NULL; /* Timestamp is unset */
 
        if (style == TIMESTAMP_UNIX) {
                if (l < (size_t) (1 + 1 + 1))
                        return NULL; /* not enough space for even the shortest of forms */
 
                return snprintf_ok(buf, l, "@" USEC_FMT, t / USEC_PER_SEC);  /* round down μs → s */
        }
 
        utc = IN_SET(style, TIMESTAMP_UTC, TIMESTAMP_US_UTC, TIMESTAMP_DATE);
        us = IN_SET(style, TIMESTAMP_US, TIMESTAMP_US_UTC);
 
        if (l < (size_t) (3 +                   /* week day */
                          1 + 10 +              /* space and date */
                          style == TIMESTAMP_DATE ? 0 :
                          (1 + 8 +              /* space and time */
                           (us ? 1 + 6 : 0) +   /* "." and microsecond part */
                           1 + (utc ? 3 : 1)) + /* space and shortest possible zone */
                          1))
                return NULL; /* Not enough space even for the shortest form. */
 
        /* Let's not format times with years > 9999 */
        if (t > USEC_TIMESTAMP_FORMATTABLE_MAX) {
                static const char* const xxx[_TIMESTAMP_STYLE_MAX] = {
                        [TIMESTAMP_PRETTY] = "--- XXXX-XX-XX XX:XX:XX",
                        [TIMESTAMP_US]     = "--- XXXX-XX-XX XX:XX:XX.XXXXXX",
                        [TIMESTAMP_UTC]    = "--- XXXX-XX-XX XX:XX:XX UTC",
                        [TIMESTAMP_US_UTC] = "--- XXXX-XX-XX XX:XX:XX.XXXXXX UTC",
                        [TIMESTAMP_DATE]   = "--- XXXX-XX-XX",
                };
 
                assert(l >= strlen(xxx[style]) + 1);
                return strcpy(buf, xxx[style]);
        }
 
        if (localtime_or_gmtime_usec(t, utc, &tm) < 0)
                return NULL;
 
        /* Start with the week day */
        const char *weekday = weekday_to_string(tm.tm_wday == 0 ? 6 : tm.tm_wday - 1);
        assert(weekday);
        memcpy(buf, weekday, 4);
 
        if (style == TIMESTAMP_DATE) {
                /* Special format string if only date should be shown. */
                if (strftime(buf + 3, l - 3, " %Y-%m-%d", &tm) <= 0)
                        return NULL; /* Doesn't fit */
 
                return buf;
        }
 
        /* Add the main components */
        if (strftime(buf + 3, l - 3, " %Y-%m-%d %H:%M:%S", &tm) <= 0)
                return NULL; /* Doesn't fit */
 
        /* Append the microseconds part, if that's requested */
        if (us) {
                n = strlen(buf);
                if (n + 8 > l)
                        return NULL; /* Microseconds part doesn't fit. */
 
                sprintf(buf + n, ".%06"PRI_USEC, t % USEC_PER_SEC);
        }
 
        /* Append the timezone */
        n = strlen(buf);
        if (utc) {
                /* If this is UTC then let's explicitly use the "UTC" string here, because gmtime_r()
                 * normally uses the obsolete "GMT" instead. */
                if (n + 5 > l)
                        return NULL; /* "UTC" doesn't fit. */
 
                strcpy(buf + n, " UTC");
 
        } else if (!isempty(tm.tm_zone)) {
                size_t tn;
 
                /* An explicit timezone is specified, let's use it, if it fits */
                tn = strlen(tm.tm_zone);
                if (n + 1 + tn + 1 > l) {
                        /* The full time zone does not fit in. Yuck. */
 
                        if (n + 1 + _POSIX_TZNAME_MAX + 1 > l)
                                return NULL; /* Not even enough space for the POSIX minimum (of 6)? In that
                                              * case, complain that it doesn't fit. */
 
                        /* So the time zone doesn't fit in fully, but the caller passed enough space for the
                         * POSIX minimum time zone length. In this case suppress the timezone entirely, in
                         * order not to dump an overly long, hard to read string on the user. This should be
                         * safe, because the user will assume the local timezone anyway if none is shown. And
                         * so does parse_timestamp(). */
                } else {
                        buf[n++] = ' ';
                        strcpy(buf + n, tm.tm_zone);
                }
        }
 
        return buf;
}
 
char* format_timestamp_relative_full(char *buf, size_t l, usec_t t, clockid_t clock, bool implicit_left) {
        const char *s;
        usec_t n, d;
 
        assert(buf);
 
        if (!timestamp_is_set(t))
                return NULL;
 
        n = now(clock);
        if (n > t) {
                d = n - t;
                s = " ago";
        } else {
                d = t - n;
                s = implicit_left ? "" : " left";
        }
 
        if (d >= USEC_PER_YEAR) {
                usec_t years = d / USEC_PER_YEAR;
                usec_t months = (d % USEC_PER_YEAR) / USEC_PER_MONTH;
 
                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s%s",
                                years,
                                years == 1 ? "year" : "years",
                                months,
                                months == 1 ? "month" : "months",
                                s);
        } else if (d >= USEC_PER_MONTH) {
                usec_t months = d / USEC_PER_MONTH;
                usec_t days = (d % USEC_PER_MONTH) / USEC_PER_DAY;
 
                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s%s",
                                months,
                                months == 1 ? "month" : "months",
                                days,
                                days == 1 ? "day" : "days",
                                s);
        } else if (d >= USEC_PER_WEEK) {
                usec_t weeks = d / USEC_PER_WEEK;
                usec_t days = (d % USEC_PER_WEEK) / USEC_PER_DAY;
 
                (void) snprintf(buf, l, USEC_FMT " %s " USEC_FMT " %s%s",
                                weeks,
                                weeks == 1 ? "week" : "weeks",
                                days,
                                days == 1 ? "day" : "days",
                                s);
        } else if (d >= 2*USEC_PER_DAY)
                (void) snprintf(buf, l, USEC_FMT " days%s", d / USEC_PER_DAY,s);
        else if (d >= 25*USEC_PER_HOUR)
                (void) snprintf(buf, l, "1 day " USEC_FMT "h%s",
                                (d - USEC_PER_DAY) / USEC_PER_HOUR, s);
        else if (d >= 6*USEC_PER_HOUR)
                (void) snprintf(buf, l, USEC_FMT "h%s",
                                d / USEC_PER_HOUR, s);
        else if (d >= USEC_PER_HOUR)
                (void) snprintf(buf, l, USEC_FMT "h " USEC_FMT "min%s",
                                d / USEC_PER_HOUR,
                                (d % USEC_PER_HOUR) / USEC_PER_MINUTE, s);
        else if (d >= 5*USEC_PER_MINUTE)
                (void) snprintf(buf, l, USEC_FMT "min%s",
                                d / USEC_PER_MINUTE, s);
        else if (d >= USEC_PER_MINUTE)
                (void) snprintf(buf, l, USEC_FMT "min " USEC_FMT "s%s",
                                d / USEC_PER_MINUTE,
                                (d % USEC_PER_MINUTE) / USEC_PER_SEC, s);
        else if (d >= USEC_PER_SEC)
                (void) snprintf(buf, l, USEC_FMT "s%s",
                                d / USEC_PER_SEC, s);
        else if (d >= USEC_PER_MSEC)
                (void) snprintf(buf, l, USEC_FMT "ms%s",
                                d / USEC_PER_MSEC, s);
        else if (d > 0)
                (void) snprintf(buf, l, USEC_FMT"us%s",
                                d, s);
        else
                (void) snprintf(buf, l, "now");
 
        buf[l-1] = 0;
        return buf;
}
 
char* format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy) {
        static const struct {
                const char *suffix;
                usec_t usec;
        } table[] = {
                { "y",     USEC_PER_YEAR   },
                { "month", USEC_PER_MONTH  },
                { "w",     USEC_PER_WEEK   },
                { "d",     USEC_PER_DAY    },
                { "h",     USEC_PER_HOUR   },
                { "min",   USEC_PER_MINUTE },
                { "s",     USEC_PER_SEC    },
                { "ms",    USEC_PER_MSEC   },
                { "us",    1               },
        };
 
        char *p = ASSERT_PTR(buf);
        bool something = false;
 
        assert(l > 0);
 
        if (t == USEC_INFINITY) {
                strncpy(p, "infinity", l-1);
                p[l-1] = 0;
                return p;
        }
 
        if (t <= 0) {
                strncpy(p, "0", l-1);
                p[l-1] = 0;
                return p;
        }
 
        /* The result of this function can be parsed with parse_sec */
 
        FOREACH_ELEMENT(i, table) {
                int k = 0;
                size_t n;
                bool done = false;
                usec_t a, b;
 
                if (t <= 0)
                        break;
 
                if (t < accuracy && something)
                        break;
 
                if (t < i->usec)
                        continue;
 
                if (l <= 1)
                        break;
 
                a = t / i->usec;
                b = t % i->usec;
 
                /* Let's see if we should shows this in dot notation */
                if (t < USEC_PER_MINUTE && b > 0) {
                        signed char j = 0;
 
                        for (usec_t cc = i->usec; cc > 1; cc /= 10)
                                j++;
 
                        for (usec_t cc = accuracy; cc > 1; cc /= 10) {
                                b /= 10;
                                j--;
                        }
 
                        if (j > 0) {
                                k = snprintf(p, l,
                                             "%s"USEC_FMT".%0*"PRI_USEC"%s",
                                             p > buf ? " " : "",
                                             a,
                                             j,
                                             b,
                                             i->suffix);
 
                                t = 0;
                                done = true;
                        }
                }
 
                /* No? Then let's show it normally */
                if (!done) {
                        k = snprintf(p, l,
                                     "%s"USEC_FMT"%s",
                                     p > buf ? " " : "",
                                     a,
                                     i->suffix);
 
                        t = b;
                }
 
                n = MIN((size_t) k, l-1);
 
                l -= n;
                p += n;
 
                something = true;
        }
 
        *p = 0;
 
        return buf;
}
 
const char* get_tzname(bool dst) {
        /* musl leaves the DST timezone name unset if there is no DST, map this back to no DST */
        if (dst && isempty(tzname[1]))
                dst = false;
 
        return empty_to_null(tzname[dst]);
}
 
int parse_gmtoff(const char *t, long *ret) {
        assert(t);
 
        struct tm tm;
        const char *k = strptime(t, "%z", &tm);
        if (k && *k == '\0') {
                /* Success! */
                if (ret)
                        *ret = tm.tm_gmtoff;
                return 0;
        }
 
#ifdef __GLIBC__
        return -EINVAL;
#else
        int r;
 
        /* musl v1.2.5 does not support %z specifier in strptime(). Since
         * https://github.com/kraj/musl/commit/fced99e93daeefb0192fd16304f978d4401d1d77
         * %z is supported, but it only supports strict RFC-822/ISO 8601 format, that is, 4 digits with sign
         * (e.g. +0900 or -1400), but does not support extended format: 2 digits or colon separated 4 digits
         * (e.g. +09 or -14:00). Let's add fallback logic to make it support the extended timezone spec. */
 
        bool positive;
        switch (*t) {
        case '+':
                positive = true;
                break;
        case '-':
                positive = false;
                break;
        default:
                return -EINVAL;
        }
 
        t++;
        r = undecchar(*t);
        if (r < 0)
                return r;
 
        usec_t u = r * 10 * USEC_PER_HOUR;
 
        t++;
        r = undecchar(*t);
        if (r < 0)
                return r;
        u += r * USEC_PER_HOUR;
 
        t++;
        if (*t == '\0') /* 2 digits case */
                goto finalize;
 
        if (*t == ':') /* skip colon */
                t++;
 
        r = undecchar(*t);
        if (r < 0)
                return r;
        if (r >= 6) /* refuse minutes equal to or larger than 60 */
                return -EINVAL;
 
        u += r * 10 * USEC_PER_MINUTE;
 
        t++;
        r = undecchar(*t);
        if (r < 0)
                return r;
 
        u += r * USEC_PER_MINUTE;
 
        t++;
        if (*t != '\0')
                return -EINVAL;
 
finalize:
        if (u > USEC_PER_DAY) /* refuse larger than one day */
                return -EINVAL;
 
        if (ret) {
                long gmtoff = u / USEC_PER_SEC;
                *ret = positive ? gmtoff : -gmtoff;
        }
 
        return 0;
#endif
}
 
static int parse_timestamp_impl(
                const char *t,
                size_t max_len,
                bool utc,
                int isdst,
                long gmtoff,
                usec_t *ret) {
 
        static const struct {
                const char *name;
                const int nr;
        } day_nr[] = {
                { "Sunday",    0 },
                { "Sun",       0 },
                { "Monday",    1 },
                { "Mon",       1 },
                { "Tuesday",   2 },
                { "Tue",       2 },
                { "Wednesday", 3 },
                { "Wed",       3 },
                { "Thursday",  4 },
                { "Thu",       4 },
                { "Friday",    5 },
                { "Fri",       5 },
                { "Saturday",  6 },
                { "Sat",       6 },
        };
 
        _cleanup_free_ char *t_alloc = NULL;
        usec_t usec, plus = 0, minus = 0;
        bool with_tz = false;
        int r, weekday = -1;
        unsigned fractional = 0;
        const char *k;
        struct tm tm, copy;
 
        /* Allowed syntaxes:
         *
         *   2012-09-22 16:34:22.1[2[3[4[5[6]]]]]
         *   2012-09-22 16:34:22  (µsec will be set to 0)
         *   2012-09-22 16:34     (seconds will be set to 0)
         *   2012-09-22T16:34:22.1[2[3[4[5[6]]]]]
         *   2012-09-22T16:34:22  (µsec will be set to 0)
         *   2012-09-22T16:34     (seconds will be set to 0)
         *   2012-09-22           (time will be set to 00:00:00)
         *   16:34:22             (date will be set to today)
         *   16:34                (date will be set to today, seconds to 0)
         *   now
         *   yesterday            (time is set to 00:00:00)
         *   today                (time is set to 00:00:00)
         *   tomorrow             (time is set to 00:00:00)
         *   +5min
         *   -5days
         *   @2147483647          (seconds since epoch)
         *
         * Note, on DST change, 00:00:00 may not exist and in that case the time part may be shifted.
         * E.g. "Sun 2023-03-13 America/Havana" is parsed as "Sun 2023-03-13 01:00:00 CDT".
         *
         * A simplified strptime-spelled RFC3339 ABNF looks like
         *   "%Y-%m-%d" "T" "%H" ":" "%M" ":" "%S" [".%N"] ("Z" / (("+" / "-") "%H:%M"))
         * We additionally allow no seconds and inherited timezone
         * for symmetry with our other syntaxes and improved interactive usability:
         *   "%Y-%m-%d" "T" "%H" ":" "%M" ":" ["%S" [".%N"]] ["Z" / (("+" / "-") "%H:%M")]
         * RFC3339 defines time-secfrac to as "." 1*DIGIT, but we limit to 6 digits,
         * since we're limited to 1µs resolution.
         * We also accept "Sat 2012-09-22T16:34:22", RFC3339 warns against it.
         */
 
        assert(t);
 
        if (max_len != SIZE_MAX) {
                /* If the input string contains timezone, then cut it here. */
 
                if (max_len == 0) /* Can't be the only field */
                        return -EINVAL;
 
                t_alloc = strndup(t, max_len);
                if (!t_alloc)
                        return -ENOMEM;
 
                t = t_alloc;
                with_tz = true;
        }
 
        if (utc) {
                /* glibc accepts gmtoff more than 24 hours, but we refuse it. */
                if ((usec_t) labs(gmtoff) * USEC_PER_SEC > USEC_PER_DAY)
                        return -EINVAL;
        } else {
                if (gmtoff != 0)
                        return -EINVAL;
        }
 
        if (t[0] == '@' && !with_tz)
                return parse_sec(t + 1, ret);
 
        usec = now(CLOCK_REALTIME);
 
        if (!with_tz) {
                if (streq(t, "now"))
                        goto finish;
 
                if (t[0] == '+') {
                        r = parse_sec(t+1, &plus);
                        if (r < 0)
                                return r;
 
                        goto finish;
                }
 
                if (t[0] == '-') {
                        r = parse_sec(t+1, &minus);
                        if (r < 0)
                                return r;
 
                        goto finish;
                }
 
                if ((k = endswith(t, " ago"))) {
                        _cleanup_free_ char *buf = NULL;
 
                        buf = strndup(t, k - t);
                        if (!buf)
                                return -ENOMEM;
 
                        r = parse_sec(buf, &minus);
                        if (r < 0)
                                return r;
 
                        goto finish;
                }
 
                if ((k = endswith(t, " left"))) {
                        _cleanup_free_ char *buf = NULL;
 
                        buf = strndup(t, k - t);
                        if (!buf)
                                return -ENOMEM;
 
                        r = parse_sec(buf, &plus);
                        if (r < 0)
                                return r;
 
                        goto finish;
                }
        }
 
        r = localtime_or_gmtime_usec(usec, utc, &tm);
        if (r < 0)
                return r;
 
        tm.tm_isdst = isdst;
 
        if (streq(t, "today")) {
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto from_tm;
 
        } else if (streq(t, "yesterday")) {
                tm.tm_mday--;
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto from_tm;
 
        } else if (streq(t, "tomorrow")) {
                tm.tm_mday++;
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto from_tm;
        }
 
        FOREACH_ELEMENT(day, day_nr) {
                k = startswith_no_case(t, day->name);
                if (!k || *k != ' ')
                        continue;
 
#ifdef __GLIBC__
                /* musl does not set tm_wday field and set 0 unless it is explicitly requested by %w or so.
                 * In the below, let's only check tm_wday field only when built with glibc. */
                weekday = day->nr;
#endif
                t = k + 1;
                break;
        }
 
        copy = tm;
        k = strptime(t, "%y-%m-%d %H:%M:%S", &tm);
        if (k) {
                if (*k == '.')
                        goto parse_usec;
                else if (*k == 0)
                        goto from_tm;
        }
 
        /* Our "canonical" RFC3339 syntax variant */
        tm = copy;
        k = strptime(t, "%Y-%m-%d %H:%M:%S", &tm);
        if (k) {
                if (*k == '.')
                        goto parse_usec;
                else if (*k == 0)
                        goto from_tm;
        }
 
        /* RFC3339 syntax */
        tm = copy;
        k = strptime(t, "%Y-%m-%dT%H:%M:%S", &tm);
        if (k) {
                if (*k == '.')
                        goto parse_usec;
                else if (*k == 0)
                        goto from_tm;
        }
 
        /* Support OUTPUT_SHORT and OUTPUT_SHORT_PRECISE formats */
        tm = copy;
        k = strptime(t, "%b %d %H:%M:%S", &tm);
        if (k) {
                if (*k == '.')
                        goto parse_usec;
                else if (*k == 0)
                        goto from_tm;
        }
 
        tm = copy;
        k = strptime(t, "%y-%m-%d %H:%M", &tm);
        if (k && *k == 0) {
                tm.tm_sec = 0;
                goto from_tm;
        }
 
        /* Our "canonical" RFC3339 syntax variant without seconds */
        tm = copy;
        k = strptime(t, "%Y-%m-%d %H:%M", &tm);
        if (k && *k == 0) {
                tm.tm_sec = 0;
                goto from_tm;
        }
 
        /* RFC3339 syntax without seconds */
        tm = copy;
        k = strptime(t, "%Y-%m-%dT%H:%M", &tm);
        if (k && *k == 0) {
                tm.tm_sec = 0;
                goto from_tm;
        }
 
        tm = copy;
        k = strptime(t, "%y-%m-%d", &tm);
        if (k && *k == 0) {
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto from_tm;
        }
 
        tm = copy;
        k = strptime(t, "%Y-%m-%d", &tm);
        if (k && *k == 0) {
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto from_tm;
        }
 
        tm = copy;
        k = strptime(t, "%H:%M:%S", &tm);
        if (k) {
                if (*k == '.')
                        goto parse_usec;
                else if (*k == 0)