/* SPDX-License-Identifier: LGPL-2.1-or-later */

#include "nm-sd-adapt-shared.h"

#include <ctype.h>

#include <errno.h>

#include <limits.h>

#include <stdlib.h>

#include <sys/mman.h>

#include <sys/time.h>

#include <sys/timerfd.h>

#include <sys/timex.h>

#include <sys/types.h>

#include <unistd.h>

#include "alloc-util.h"

#include "fd-util.h"

#include "fileio.h"

#include "fs-util.h"

#include "io-util.h"

#include "log.h"

#include "macro.h"

#include "missing_timerfd.h"

#include "parse-util.h"

#include "path-util.h"

#include "process-util.h"

#include "stat-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);

        return timespec_load(&ts);

}

nsec_t now_nsec(clockid_t clock_id) {

        struct timespec ts;

        assert_se(clock_gettime(map_clock_id(clock_id), &ts) == 0);

        return timespec_load_nsec(&ts);

}

dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {

        assert(ts);

        ts->realtime = now(CLOCK_REALTIME);

        ts->monotonic = now(CLOCK_MONOTONIC);

        return ts;

}

triple_timestamp* triple_timestamp_get(triple_timestamp *ts) {

        assert(ts);

        ts->realtime = now(CLOCK_REALTIME);

        ts->monotonic = now(CLOCK_MONOTONIC);

        ts->boottime = clock_boottime_supported() ? now(CLOCK_BOOTTIME) : USEC_INFINITY;

        return ts;

}

static usec_t map_clock_usec_internal(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_internal(from, now(from_clock), now(to_clock));

}

dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {

        assert(ts);

        if (u == USEC_INFINITY || u == 0) {

                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 (u == USEC_INFINITY || u == 0) {

                ts->realtime = ts->monotonic = ts->boottime = u;

                return ts;

        }

        nowr = now(CLOCK_REALTIME);

        ts->realtime = u;

        ts->monotonic = map_clock_usec_internal(u, nowr, now(CLOCK_MONOTONIC));

        ts->boottime = clock_boottime_supported() ?

                map_clock_usec_internal(u, nowr, now(CLOCK_BOOTTIME)) :

                USEC_INFINITY;

        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_or_monotonic(dual_timestamp *ts, usec_t u) {

        clockid_t cid;

        usec_t nowm;

        if (u == USEC_INFINITY) {

                ts->realtime = ts->monotonic = USEC_INFINITY;

                return ts;

        }

        cid = clock_boottime_or_monotonic();

        nowm = now(cid);

        if (cid == CLOCK_MONOTONIC)

                ts->monotonic = u;

        else

                ts->monotonic = map_clock_usec_internal(u, nowm, now(CLOCK_MONOTONIC));

        ts->realtime = map_clock_usec_internal(u, nowm, now(CLOCK_REALTIME));

        return ts;

}

usec_t triple_timestamp_by_clock(triple_timestamp *ts, clockid_t clock) {

        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;

}

#if 0 /* NM_IGNORED */

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;

}

char *format_timestamp_style(

                char *buf,

                size_t l,

                usec_t t,

                TimestampStyle style) {

        /* The weekdays in non-localized (English) form. We use this instead of the localized form, so that our

         * generated timestamps may be parsed with parse_timestamp(), and always read the same. */

        static const char * const weekdays[] = {

                [0] = "Sun",

                [1] = "Mon",

                [2] = "Tue",

                [3] = "Wed",

                [4] = "Thu",

                [5] = "Fri",

                [6] = "Sat",

        };

        struct tm tm;

        time_t sec;

        size_t n;

        bool utc = false, us = false;

        assert(buf);

        switch (style) {

                case TIMESTAMP_PRETTY:

                        break;

                case TIMESTAMP_US:

                        us = true;

                        break;

                case TIMESTAMP_UTC:

                        utc = true;

                        break;

                case TIMESTAMP_US_UTC:

                        us = true;

                        utc = true;

                        break;

                default:

                        return NULL;

        }

        if (l < (size_t) (3 +                  /* week day */

                          1 + 10 +             /* space and date */

                          1 + 8 +              /* space and time */

                          (us ? 1 + 6 : 0) +   /* "." and microsecond part */

                          1 + 1 +              /* space and shortest possible zone */

                          1))

                return NULL; /* Not enough space even for the shortest form. */

        if (t <= 0 || t == USEC_INFINITY)

                return NULL; /* Timestamp is unset */

        /* Let's not format times with years > 9999 */

        if (t > USEC_TIMESTAMP_FORMATTABLE_MAX) {

                assert(l >= STRLEN("--- XXXX-XX-XX XX:XX:XX") + 1);

                strcpy(buf, "--- XXXX-XX-XX XX:XX:XX");

                return buf;

        }

        sec = (time_t) (t / USEC_PER_SEC); /* Round down */

        if (!localtime_or_gmtime_r(&sec, &tm, utc))

                return NULL;

        /* Start with the week day */

        assert((size_t) tm.tm_wday < ELEMENTSOF(weekdays));

        memcpy(buf, weekdays[tm.tm_wday], 4);

        /* 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(char *buf, size_t l, usec_t t) {

        const char *s;

        usec_t n, d;

        if (t <= 0 || t == USEC_INFINITY)

                return NULL;

        n = now(CLOCK_REALTIME);

        if (n > t) {

                d = n - t;

                s = "ago";

        } else {

                d = t - n;

                s = "left";

        }

        if (d >= USEC_PER_YEAR)

                snprintf(buf, l, USEC_FMT " years " USEC_FMT " months %s",

                         d / USEC_PER_YEAR,

                         (d % USEC_PER_YEAR) / USEC_PER_MONTH, s);

        else if (d >= USEC_PER_MONTH)

                snprintf(buf, l, USEC_FMT " months " USEC_FMT " days %s",

                         d / USEC_PER_MONTH,

                         (d % USEC_PER_MONTH) / USEC_PER_DAY, s);

        else if (d >= USEC_PER_WEEK)

                snprintf(buf, l, USEC_FMT " weeks " USEC_FMT " days %s",

                         d / USEC_PER_WEEK,

                         (d % USEC_PER_WEEK) / USEC_PER_DAY, s);

        else if (d >= 2*USEC_PER_DAY)

                snprintf(buf, l, USEC_FMT " days %s", d / USEC_PER_DAY, s);

        else if (d >= 25*USEC_PER_HOUR)

                snprintf(buf, l, "1 day " USEC_FMT "h %s",

                         (d - USEC_PER_DAY) / USEC_PER_HOUR, s);

        else if (d >= 6*USEC_PER_HOUR)

                snprintf(buf, l, USEC_FMT "h %s",

                         d / USEC_PER_HOUR, s);

        else if (d >= USEC_PER_HOUR)

                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)

                snprintf(buf, l, USEC_FMT "min %s",

                         d / USEC_PER_MINUTE, s);

        else if (d >= USEC_PER_MINUTE)

                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)

                snprintf(buf, l, USEC_FMT "s %s",

                         d / USEC_PER_SEC, s);

        else if (d >= USEC_PER_MSEC)

                snprintf(buf, l, USEC_FMT "ms %s",

                         d / USEC_PER_MSEC, s);

        else if (d > 0)

                snprintf(buf, l, USEC_FMT"us %s",

                         d, s);

        else

                snprintf(buf, l, "now");

        buf[l-1] = 0;

        return buf;

}

#endif /* NM_IGNORED */

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

        };

        size_t i;

        char *p = buf;

        bool something = false;

        assert(buf);

        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 */

        for (i = 0; i < ELEMENTSOF(table); i++) {

                int k = 0;

                size_t n;

                bool done = false;

                usec_t a, b;

                if (t <= 0)

                        break;

                if (t < accuracy && something)

                        break;

                if (t < table[i].usec)

                        continue;

                if (l <= 1)

                        break;

                a = t / table[i].usec;

                b = t % table[i].usec;

                /* Let's see if we should shows this in dot notation */

                if (t < USEC_PER_MINUTE && b > 0) {

                        usec_t cc;

                        signed char j;

                        j = 0;

                        for (cc = table[i].usec; cc > 1; cc /= 10)

                                j++;

                        for (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,

                                             table[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,

                                     table[i].suffix);

                        t = b;

                }

                n = MIN((size_t) k, l);

                l -= n;

                p += n;

                something = true;

        }

        *p = 0;

        return buf;

}

#if 0 /* NM_IGNORED */

static int parse_timestamp_impl(const char *t, usec_t *usec, bool with_tz) {

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

        };

        const char *k, *utc = NULL, *tzn = NULL;

        struct tm tm, copy;

        time_t x;

        usec_t x_usec, plus = 0, minus = 0, ret;

        int r, weekday = -1, dst = -1;

        size_t i;

        /* Allowed syntaxes:

         *

         *   2012-09-22 16:34:22

         *   2012-09-22 16: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)

         */

        assert(t);

        if (t[0] == '@' && !with_tz)

                return parse_sec(t + 1, usec);

        ret = now(CLOCK_REALTIME);

        if (!with_tz) {

                if (streq(t, "now"))

                        goto finish;

                else if (t[0] == '+') {

                        r = parse_sec(t+1, &plus);

                        if (r < 0)

                                return r;

                        goto finish;

                } else if (t[0] == '-') {

                        r = parse_sec(t+1, &minus);

                        if (r < 0)

                                return r;

                        goto finish;

                } else if ((k = endswith(t, " ago"))) {

                        t = strndupa(t, k - t);

                        r = parse_sec(t, &minus);

                        if (r < 0)

                                return r;

                        goto finish;

                } else if ((k = endswith(t, " left"))) {

                        t = strndupa(t, k - t);

                        r = parse_sec(t, &plus);

                        if (r < 0)

                                return r;

                        goto finish;

                }

                /* See if the timestamp is suffixed with UTC */

                utc = endswith_no_case(t, " UTC");

                if (utc)

                        t = strndupa(t, utc - t);

                else {

                        const char *e = NULL;

                        int j;

                        tzset();

                        /* See if the timestamp is suffixed by either the DST or non-DST local timezone. Note that we only

                         * support the local timezones here, nothing else. Not because we wouldn't want to, but simply because

                         * there are no nice APIs available to cover this. By accepting the local time zone strings, we make

                         * sure that all timestamps written by format_timestamp() can be parsed correctly, even though we don't

                         * support arbitrary timezone specifications. */

                        for (j = 0; j <= 1; j++) {

                                if (isempty(tzname[j]))

                                        continue;

                                e = endswith_no_case(t, tzname[j]);

                                if (!e)

                                        continue;

                                if (e == t)

                                        continue;

                                if (e[-1] != ' ')

                                        continue;

                                break;

                        }

                        if (IN_SET(j, 0, 1)) {

                                /* Found one of the two timezones specified. */

                                t = strndupa(t, e - t - 1);

                                dst = j;

                                tzn = tzname[j];

                        }

                }

        }

        x = (time_t) (ret / USEC_PER_SEC);

        x_usec = 0;

        if (!localtime_or_gmtime_r(&x, &tm, utc))

                return -EINVAL;

        tm.tm_isdst = dst;

        if (!with_tz && tzn)

                tm.tm_zone = tzn;

        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;

        }

        for (i = 0; i < ELEMENTSOF(day_nr); i++) {

                size_t skip;

                if (!startswith_no_case(t, day_nr[i].name))

                        continue;

                skip = strlen(day_nr[i].name);

                if (t[skip] != ' ')

                        continue;

                weekday = day_nr[i].nr;

                t += skip + 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;

        }

        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;

        }

        tm = copy;

        k = strptime(t, "%y-%m-%d %H:%M", &tm;;

        if (k && *k == 0) {

                tm.tm_sec = 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;

        }

        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)

                        goto from_tm;

        }

        tm = copy;

        k = strptime(t, "%H:%M", &tm;;

        if (k && *k == 0) {

                tm.tm_sec = 0;

                goto from_tm;

        }

        return -EINVAL;

parse_usec:

        {

                unsigned add;

                k++;

                r = parse_fractional_part_u(&k, 6, &add);

                if (r < 0)

                        return -EINVAL;

                if (*k)

                        return -EINVAL;

                x_usec = add;

        }

from_tm:

        if (weekday >= 0 && tm.tm_wday != weekday)

                return -EINVAL;

        x = mktime_or_timegm(&tm, utc);

        if (x < 0)

                return -EINVAL;

        ret = (usec_t) x * USEC_PER_SEC + x_usec;

        if (ret > USEC_TIMESTAMP_FORMATTABLE_MAX)

                return -EINVAL;

finish:

        if (ret + plus < ret) /* overflow? */

                return -EINVAL;

        ret += plus;

        if (ret > USEC_TIMESTAMP_FORMATTABLE_MAX)

                return -EINVAL;

        if (ret >= minus)

                ret -= minus;

        else

                return -EINVAL;

        if (usec)

                *usec = ret;

        return 0;

}

typedef struct ParseTimestampResult {

        usec_t usec;

        int return_value;

} ParseTimestampResult;

int parse_timestamp(const char *t, usec_t *usec) {

        char *last_space, *tz = NULL;

        ParseTimestampResult *shared, tmp;