[thirdparty/systemd.git] / src / shared / time-util.c

/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/

/***
  This file is part of systemd.

  Copyright 2010 Lennart Poettering

  systemd is free software; you can redistribute it and/or modify it
  under the terms of the GNU Lesser General Public License as published by
  the Free Software Foundation; either version 2.1 of the License, or
  (at your option) any later version.

  systemd 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
  Lesser General Public License for more details.

  You should have received a copy of the GNU Lesser General Public License
  along with systemd; If not, see <http://www.gnu.org/licenses/>.
***/

#include <time.h>
#include <string.h>

#include "util.h"
#include "time-util.h"

usec_t now(clockid_t clock_id) {
        struct timespec ts;

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

        return timespec_load(&ts);
}

dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
        assert(ts);

        ts->realtime = now(CLOCK_REALTIME);
        ts->monotonic = now(CLOCK_MONOTONIC);

        return ts;
}

dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
        int64_t delta;
        assert(ts);

        ts->realtime = u;

        if (u == 0)
                ts->monotonic = 0;
        else {
                delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;

                ts->monotonic = now(CLOCK_MONOTONIC);

                if ((int64_t) ts->monotonic > delta)
                        ts->monotonic -= delta;
                else
                        ts->monotonic = 0;
        }

        return ts;
}

usec_t timespec_load(const struct timespec *ts) {
        assert(ts);

        if (ts->tv_sec == (time_t) -1 &&
            ts->tv_nsec == (long) -1)
                return (usec_t) -1;

        if ((usec_t) ts->tv_sec > (UINT64_MAX - (ts->tv_nsec / NSEC_PER_USEC)) / USEC_PER_SEC)
                return (usec_t) -1;

        return
                (usec_t) ts->tv_sec * USEC_PER_SEC +
                (usec_t) ts->tv_nsec / NSEC_PER_USEC;
}

struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
        assert(ts);

        if (u == (usec_t) -1) {
                ts->tv_sec = (time_t) -1;
                ts->tv_nsec = (long) -1;
                return ts;
        }

        ts->tv_sec = (time_t) (u / USEC_PER_SEC);
        ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);

        return ts;
}

usec_t timeval_load(const struct timeval *tv) {
        assert(tv);

        if (tv->tv_sec == (time_t) -1 &&
            tv->tv_usec == (suseconds_t) -1)
                return (usec_t) -1;

        if ((usec_t) tv->tv_sec > (UINT64_MAX - tv->tv_usec) / USEC_PER_SEC)
                return (usec_t) -1;

        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_t) -1) {
                tv->tv_sec = (time_t) -1;
                tv->tv_usec = (suseconds_t) -1;
                return tv;
        }

        tv->tv_sec = (time_t) (u / USEC_PER_SEC);
        tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);

        return tv;
}

char *format_timestamp(char *buf, size_t l, usec_t t) {
        struct tm tm;
        time_t sec;

        assert(buf);
        assert(l > 0);

        if (t <= 0)
                return NULL;

        sec = (time_t) (t / USEC_PER_SEC);

        if (strftime(buf, l, "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&sec, &tm)) <= 0)
                return NULL;

        return buf;
}

char *format_timestamp_relative(char *buf, size_t l, usec_t t) {
        usec_t n, d;

        n = now(CLOCK_REALTIME);

        if (t <= 0 || t > n || t + USEC_PER_DAY*7 <= t)
                return NULL;

        d = n - t;

        if (d >= USEC_PER_YEAR)
                snprintf(buf, l, "%llu years %llu months ago",
                         (unsigned long long) (d / USEC_PER_YEAR),
                         (unsigned long long) ((d % USEC_PER_YEAR) / USEC_PER_MONTH));
        else if (d >= USEC_PER_MONTH)
                snprintf(buf, l, "%llu months %llu days ago",
                         (unsigned long long) (d / USEC_PER_MONTH),
                         (unsigned long long) ((d % USEC_PER_MONTH) / USEC_PER_DAY));
        else if (d >= USEC_PER_WEEK)
                snprintf(buf, l, "%llu weeks %llu days ago",
                         (unsigned long long) (d / USEC_PER_WEEK),
                         (unsigned long long) ((d % USEC_PER_WEEK) / USEC_PER_DAY));
        else if (d >= 2*USEC_PER_DAY)
                snprintf(buf, l, "%llu days ago", (unsigned long long) (d / USEC_PER_DAY));
        else if (d >= 25*USEC_PER_HOUR)
                snprintf(buf, l, "1 day %lluh ago",
                         (unsigned long long) ((d - USEC_PER_DAY) / USEC_PER_HOUR));
        else if (d >= 6*USEC_PER_HOUR)
                snprintf(buf, l, "%lluh ago",
                         (unsigned long long) (d / USEC_PER_HOUR));
        else if (d >= USEC_PER_HOUR)
                snprintf(buf, l, "%lluh %llumin ago",
                         (unsigned long long) (d / USEC_PER_HOUR),
                         (unsigned long long) ((d % USEC_PER_HOUR) / USEC_PER_MINUTE));
        else if (d >= 5*USEC_PER_MINUTE)
                snprintf(buf, l, "%llumin ago",
                         (unsigned long long) (d / USEC_PER_MINUTE));
        else if (d >= USEC_PER_MINUTE)
                snprintf(buf, l, "%llumin %llus ago",
                         (unsigned long long) (d / USEC_PER_MINUTE),
                         (unsigned long long) ((d % USEC_PER_MINUTE) / USEC_PER_SEC));
        else if (d >= USEC_PER_SEC)
                snprintf(buf, l, "%llus ago",
                         (unsigned long long) (d / USEC_PER_SEC));
        else if (d >= USEC_PER_MSEC)
                snprintf(buf, l, "%llums ago",
                         (unsigned long long) (d / USEC_PER_MSEC));
        else if (d > 0)
                snprintf(buf, l, "%lluus ago",
                         (unsigned long long) d);
        else
                snprintf(buf, l, "now");

        buf[l-1] = 0;
        return buf;
}

char *format_timespan(char *buf, size_t l, usec_t t) {
        static const struct {
                const char *suffix;
                usec_t usec;
        } table[] = {
                { "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 },
        };

        unsigned i;
        char *p = buf;

        assert(buf);
        assert(l > 0);

        if (t == (usec_t) -1)
                return NULL;

        if (t == 0) {
                snprintf(p, l, "0");
                p[l-1] = 0;
                return p;
        }

        /* The result of this function can be parsed with parse_usec */

        for (i = 0; i < ELEMENTSOF(table); i++) {
                int k;
                size_t n;

                if (t < table[i].usec)
                        continue;

                if (l <= 1)
                        break;

                k = snprintf(p, l, "%s%llu%s", p > buf ? " " : "", (unsigned long long) (t / table[i].usec), table[i].suffix);
                n = MIN((size_t) k, l);

                l -= n;
                p += n;

                t %= table[i].usec;
        }

        *p = 0;

        return buf;
}

void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {

        assert(f);
        assert(name);
        assert(t);

        if (!dual_timestamp_is_set(t))
                return;

        fprintf(f, "%s=%llu %llu\n",
                name,
                (unsigned long long) t->realtime,
                (unsigned long long) t->monotonic);
}

void dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
        unsigned long long a, b;

        assert(value);
        assert(t);

        if (sscanf(value, "%lli %llu", &a, &b) != 2)
                log_debug("Failed to parse finish timestamp value %s", value);
        else {
                t->realtime = a;
                t->monotonic = b;
        }
}

int parse_timestamp(const char *t, usec_t *usec) {
        const char *k;
        struct tm tm, copy;
        time_t x;
        usec_t plus = 0, minus = 0, ret;
        int r;

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

        assert(t);
        assert(usec);

        x = time(NULL);
        assert_se(localtime_r(&x, &tm));

        if (streq(t, "now"))
                goto finish;

        else if (streq(t, "today")) {
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto finish;

        } else if (streq(t, "yesterday")) {
                tm.tm_mday --;
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto finish;

        } else if (streq(t, "tomorrow")) {
                tm.tm_mday ++;
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto finish;

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

                r = parse_usec(t+1, &plus);
                if (r < 0)
                        return r;

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

                r = parse_usec(t+1, &minus);
                if (r < 0)
                        return r;

                goto finish;
        }

        copy = tm;
        k = strptime(t, "%y-%m-%d %H:%M:%S", &tm);
        if (k && *k == 0)
                goto finish;

        tm = copy;
        k = strptime(t, "%Y-%m-%d %H:%M:%S", &tm);
        if (k && *k == 0)
                goto finish;

        tm = copy;
        k = strptime(t, "%y-%m-%d %H:%M", &tm);
        if (k && *k == 0) {
                tm.tm_sec = 0;
                goto finish;
        }

        tm = copy;
        k = strptime(t, "%Y-%m-%d %H:%M", &tm);
        if (k && *k == 0) {
                tm.tm_sec = 0;
                goto finish;
        }

        tm = copy;
        k = strptime(t, "%y-%m-%d", &tm);
        if (k && *k == 0) {
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto finish;
        }

        tm = copy;
        k = strptime(t, "%Y-%m-%d", &tm);
        if (k && *k == 0) {
                tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
                goto finish;
        }

        tm = copy;
        k = strptime(t, "%H:%M:%S", &tm);
        if (k && *k == 0)
                goto finish;

        tm = copy;
        k = strptime(t, "%H:%M", &tm);
        if (k && *k == 0) {
                tm.tm_sec = 0;
                goto finish;
        }

        return -EINVAL;

finish:
        x = mktime(&tm);
        if (x == (time_t) -1)
                return -EINVAL;

        ret = (usec_t) x * USEC_PER_SEC;

        ret += plus;
        if (ret > minus)
                ret -= minus;
        else
                ret = 0;

        *usec = ret;

        return 0;
}

int parse_usec(const char *t, usec_t *usec) {
        static const struct {
                const char *suffix;
                usec_t usec;
        } table[] = {
                { "seconds", USEC_PER_SEC },
                { "second", USEC_PER_SEC },
                { "sec", USEC_PER_SEC },
                { "s", USEC_PER_SEC },
                { "minutes", USEC_PER_MINUTE },
                { "minute", USEC_PER_MINUTE },
                { "min", USEC_PER_MINUTE },
                { "months", USEC_PER_MONTH },
                { "month", USEC_PER_MONTH },
                { "msec", USEC_PER_MSEC },
                { "ms", USEC_PER_MSEC },
                { "m", USEC_PER_MINUTE },
                { "hours", USEC_PER_HOUR },
                { "hour", USEC_PER_HOUR },
                { "hr", USEC_PER_HOUR },
                { "h", USEC_PER_HOUR },
                { "days", USEC_PER_DAY },
                { "day", USEC_PER_DAY },
                { "d", USEC_PER_DAY },
                { "weeks", USEC_PER_WEEK },
                { "week", USEC_PER_WEEK },
                { "w", USEC_PER_WEEK },
                { "years", USEC_PER_YEAR },
                { "year", USEC_PER_YEAR },
                { "y", USEC_PER_YEAR },
                { "usec", 1ULL },
                { "us", 1ULL },
                { "", USEC_PER_SEC }, /* default is sec */
        };

        const char *p;
        usec_t r = 0;

        assert(t);
        assert(usec);

        p = t;
        do {
                long long l;
                char *e;
                unsigned i;

                errno = 0;
                l = strtoll(p, &e, 10);

                if (errno != 0)
                        return -errno;

                if (l < 0)
                        return -ERANGE;

                if (e == p)
                        return -EINVAL;

                e += strspn(e, WHITESPACE);

                for (i = 0; i < ELEMENTSOF(table); i++)
                        if (startswith(e, table[i].suffix)) {
                                r += (usec_t) l * table[i].usec;
                                p = e + strlen(table[i].suffix);
                                break;
                        }

                if (i >= ELEMENTSOF(table))
                        return -EINVAL;

        } while (*p != 0);

        *usec = r;

        return 0;
}

int parse_nsec(const char *t, nsec_t *nsec) {
        static const struct {
                const char *suffix;
                nsec_t nsec;
        } table[] = {
                { "seconds", NSEC_PER_SEC },
                { "second", NSEC_PER_SEC },
                { "sec", NSEC_PER_SEC },
                { "s", NSEC_PER_SEC },
                { "minutes", NSEC_PER_MINUTE },
                { "minute", NSEC_PER_MINUTE },
                { "min", NSEC_PER_MINUTE },
                { "months", NSEC_PER_MONTH },
                { "month", NSEC_PER_MONTH },
                { "msec", NSEC_PER_MSEC },
                { "ms", NSEC_PER_MSEC },
                { "m", NSEC_PER_MINUTE },
                { "hours", NSEC_PER_HOUR },
                { "hour", NSEC_PER_HOUR },
                { "hr", NSEC_PER_HOUR },
                { "h", NSEC_PER_HOUR },
                { "days", NSEC_PER_DAY },
                { "day", NSEC_PER_DAY },
                { "d", NSEC_PER_DAY },
                { "weeks", NSEC_PER_WEEK },
                { "week", NSEC_PER_WEEK },
                { "w", NSEC_PER_WEEK },
                { "years", NSEC_PER_YEAR },
                { "year", NSEC_PER_YEAR },
                { "y", NSEC_PER_YEAR },
                { "usec", NSEC_PER_USEC },
                { "us", NSEC_PER_USEC },
                { "nsec", 1ULL },
                { "ns", 1ULL },
                { "", 1ULL }, /* default is nsec */
        };

        const char *p;
        nsec_t r = 0;

        assert(t);
        assert(nsec);

        p = t;
        do {
                long long l;
                char *e;
                unsigned i;

                errno = 0;
                l = strtoll(p, &e, 10);

                if (errno != 0)
                        return -errno;

                if (l < 0)
                        return -ERANGE;

                if (e == p)
                        return -EINVAL;

                e += strspn(e, WHITESPACE);

                for (i = 0; i < ELEMENTSOF(table); i++)
                        if (startswith(e, table[i].suffix)) {
                                r += (nsec_t) l * table[i].nsec;
                                p = e + strlen(table[i].suffix);
                                break;
                        }

                if (i >= ELEMENTSOF(table))
                        return -EINVAL;

        } while (*p != 0);

        *nsec = r;

        return 0;
}
Commit	Line	Data
9a98c7a1 LP	1	/-- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil --/
	2
	3	/***
	4	This file is part of systemd.
	5
	6	Copyright 2010 Lennart Poettering
	7
	8	systemd is free software; you can redistribute it and/or modify it
	9	under the terms of the GNU Lesser General Public License as published by
	10	the Free Software Foundation; either version 2.1 of the License, or
	11	(at your option) any later version.
	12
	13	systemd is distributed in the hope that it will be useful, but
	14	WITHOUT ANY WARRANTY; without even the implied warranty of
	15	MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
	16	Lesser General Public License for more details.
	17
	18	You should have received a copy of the GNU Lesser General Public License
	19	along with systemd; If not, see <http://www.gnu.org/licenses/>.
	20	***/
	21
	22	#include <time.h>
	23	#include <string.h>
	24
	25	#include "util.h"
	26	#include "time-util.h"
	27
	28	usec_t now(clockid_t clock_id) {
	29	struct timespec ts;
	30
	31	assert_se(clock_gettime(clock_id, &ts) == 0);
	32
	33	return timespec_load(&ts);
	34	}
	35
	36	dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
	37	assert(ts);
	38
	39	ts->realtime = now(CLOCK_REALTIME);
	40	ts->monotonic = now(CLOCK_MONOTONIC);
	41
	42	return ts;
	43	}
	44
	45	dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
	46	int64_t delta;
	47	assert(ts);
	48
	49	ts->realtime = u;
	50
	51	if (u == 0)
	52	ts->monotonic = 0;
	53	else {
	54	delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
	55
	56	ts->monotonic = now(CLOCK_MONOTONIC);
	57
	58	if ((int64_t) ts->monotonic > delta)
	59	ts->monotonic -= delta;
	60	else
	61	ts->monotonic = 0;
	62	}
	63
	64	return ts;
65	}
66
67	usec_t timespec_load(const struct timespec *ts) {
68	assert(ts);
69
70	if (ts->tv_sec == (time_t) -1 &&
71	ts->tv_nsec == (long) -1)
72	return (usec_t) -1;
73
74	if ((usec_t) ts->tv_sec > (UINT64_MAX - (ts->tv_nsec / NSEC_PER_USEC)) / USEC_PER_SEC)
75	return (usec_t) -1;
76
77	return
78	(usec_t) ts->tv_sec * USEC_PER_SEC +
79	(usec_t) ts->tv_nsec / NSEC_PER_USEC;
80	}
81
82	struct timespec timespec_store(struct timespec ts, usec_t u) {
83	assert(ts);
84
85	if (u == (usec_t) -1) {
86	ts->tv_sec = (time_t) -1;
87	ts->tv_nsec = (long) -1;
88	return ts;
89	}
90
91	ts->tv_sec = (time_t) (u / USEC_PER_SEC);
92	ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
93
94	return ts;
95	}
96
97	usec_t timeval_load(const struct timeval *tv) {
98	assert(tv);
99
100	if (tv->tv_sec == (time_t) -1 &&
101	tv->tv_usec == (suseconds_t) -1)
102	return (usec_t) -1;
103
104	if ((usec_t) tv->tv_sec > (UINT64_MAX - tv->tv_usec) / USEC_PER_SEC)
105	return (usec_t) -1;
106
107	return
108	(usec_t) tv->tv_sec * USEC_PER_SEC +
109	(usec_t) tv->tv_usec;
110	}
111
112	struct timeval timeval_store(struct timeval tv, usec_t u) {
113	assert(tv);
114
115	if (u == (usec_t) -1) {
116	tv->tv_sec = (time_t) -1;
117	tv->tv_usec = (suseconds_t) -1;
118	return tv;
119	}
120
121	tv->tv_sec = (time_t) (u / USEC_PER_SEC);
122	tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
123
124	return tv;
125	}
126
127	char format_timestamp(char buf, size_t l, usec_t t) {
128	struct tm tm;
129	time_t sec;
130
131	assert(buf);
132	assert(l > 0);
133
134	if (t <= 0)
135	return NULL;
136
137	sec = (time_t) (t / USEC_PER_SEC);
138
139	if (strftime(buf, l, "%a %Y-%m-%d %H:%M:%S %Z", localtime_r(&sec, &tm)) <= 0)
140	return NULL;
141
142	return buf;
143	}
144
bbb8486e	145	char format_timestamp_relative(char buf, size_t l, usec_t t) {
9a98c7a1 LP	146	usec_t n, d;
	147
	148	n = now(CLOCK_REALTIME);
	149
	150	if (t <= 0 \|\| t > n \|\| t + USEC_PER_DAY*7 <= t)
	151	return NULL;
	152
	153	d = n - t;
	154
	155	if (d >= USEC_PER_YEAR)
	156	snprintf(buf, l, "%llu years %llu months ago",
	157	(unsigned long long) (d / USEC_PER_YEAR),
	158	(unsigned long long) ((d % USEC_PER_YEAR) / USEC_PER_MONTH));
	159	else if (d >= USEC_PER_MONTH)
	160	snprintf(buf, l, "%llu months %llu days ago",
	161	(unsigned long long) (d / USEC_PER_MONTH),
	162	(unsigned long long) ((d % USEC_PER_MONTH) / USEC_PER_DAY));
	163	else if (d >= USEC_PER_WEEK)
	164	snprintf(buf, l, "%llu weeks %llu days ago",
	165	(unsigned long long) (d / USEC_PER_WEEK),
	166	(unsigned long long) ((d % USEC_PER_WEEK) / USEC_PER_DAY));
	167	else if (d >= 2*USEC_PER_DAY)
	168	snprintf(buf, l, "%llu days ago", (unsigned long long) (d / USEC_PER_DAY));
	169	else if (d >= 25*USEC_PER_HOUR)
	170	snprintf(buf, l, "1 day %lluh ago",
	171	(unsigned long long) ((d - USEC_PER_DAY) / USEC_PER_HOUR));
	172	else if (d >= 6*USEC_PER_HOUR)
	173	snprintf(buf, l, "%lluh ago",
	174	(unsigned long long) (d / USEC_PER_HOUR));
	175	else if (d >= USEC_PER_HOUR)
	176	snprintf(buf, l, "%lluh %llumin ago",
	177	(unsigned long long) (d / USEC_PER_HOUR),
	178	(unsigned long long) ((d % USEC_PER_HOUR) / USEC_PER_MINUTE));
	179	else if (d >= 5*USEC_PER_MINUTE)
	180	snprintf(buf, l, "%llumin ago",
	181	(unsigned long long) (d / USEC_PER_MINUTE));
	182	else if (d >= USEC_PER_MINUTE)
	183	snprintf(buf, l, "%llumin %llus ago",
	184	(unsigned long long) (d / USEC_PER_MINUTE),
	185	(unsigned long long) ((d % USEC_PER_MINUTE) / USEC_PER_SEC));
	186	else if (d >= USEC_PER_SEC)
	187	snprintf(buf, l, "%llus ago",
	188	(unsigned long long) (d / USEC_PER_SEC));
	189	else if (d >= USEC_PER_MSEC)
	190	snprintf(buf, l, "%llums ago",
	191	(unsigned long long) (d / USEC_PER_MSEC));
	192	else if (d > 0)
	193	snprintf(buf, l, "%lluus ago",
	194	(unsigned long long) d);
	195	else
	196	snprintf(buf, l, "now");
	197
	198	buf[l-1] = 0;
	199	return buf;
	200	}
	201
	202	char format_timespan(char buf, size_t l, usec_t t) {
	203	static const struct {
	204	const char *suffix;
	205	usec_t usec;
	206	} table[] = {
	207	{ "w", USEC_PER_WEEK },
	208	{ "d", USEC_PER_DAY },
	209	{ "h", USEC_PER_HOUR },
210	{ "min", USEC_PER_MINUTE },
211	{ "s", USEC_PER_SEC },
212	{ "ms", USEC_PER_MSEC },
213	{ "us", 1 },
214	};
215
216	unsigned i;
217	char *p = buf;
218
219	assert(buf);
220	assert(l > 0);
221
222	if (t == (usec_t) -1)
223	return NULL;
224
225	if (t == 0) {
226	snprintf(p, l, "0");
227	p[l-1] = 0;
228	return p;
229	}
230
231	/* The result of this function can be parsed with parse_usec */
232
233	for (i = 0; i < ELEMENTSOF(table); i++) {
234	int k;
235	size_t n;
236
237	if (t < table[i].usec)
238	continue;
239
240	if (l <= 1)
241	break;
242
243	k = snprintf(p, l, "%s%llu%s", p > buf ? " " : "", (unsigned long long) (t / table[i].usec), table[i].suffix);
244	n = MIN((size_t) k, l);
245
246	l -= n;
247	p += n;
248
249	t %= table[i].usec;
250	}
251
252	*p = 0;
253
254	return buf;
255	}
256
257	void dual_timestamp_serialize(FILE f, const char name, dual_timestamp *t) {
258
259	assert(f);
260	assert(name);
261	assert(t);
262
263	if (!dual_timestamp_is_set(t))
264	return;
265
266	fprintf(f, "%s=%llu %llu\n",
267	name,
268	(unsigned long long) t->realtime,
269	(unsigned long long) t->monotonic);
270	}
271
272	void dual_timestamp_deserialize(const char value, dual_timestamp t) {
273	unsigned long long a, b;
274
275	assert(value);
276	assert(t);
277
278	if (sscanf(value, "%lli %llu", &a, &b) != 2)
279	log_debug("Failed to parse finish timestamp value %s", value);
280	else {
281	t->realtime = a;
282	t->monotonic = b;
283	}
284	}
285
286	int parse_timestamp(const char t, usec_t usec) {
287	const char *k;
288	struct tm tm, copy;
289	time_t x;
290	usec_t plus = 0, minus = 0, ret;
291	int r;
292
293	/*
294	* Allowed syntaxes:
295	*
296	* 2012-09-22 16:34:22
297	* 2012-09-22 16:34 (seconds will be set to 0)
298	* 2012-09-22 (time will be set to 00:00:00)
299	* 16:34:22 (date will be set to today)
300	* 16:34 (date will be set to today, seconds to 0)
301	* now
302	* yesterday (time is set to 00:00:00)
303	* today (time is set to 00:00:00)
304	* tomorrow (time is set to 00:00:00)
305	* +5min
306	* -5days
307	*
308	*/
309
310	assert(t);
311	assert(usec);
312
313	x = time(NULL);
314	assert_se(localtime_r(&x, &tm));
315
316	if (streq(t, "now"))
317	goto finish;
318
319	else if (streq(t, "today")) {
320	tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
321	goto finish;
322
323	} else if (streq(t, "yesterday")) {
324	tm.tm_mday --;
325	tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
326	goto finish;
327
328	} else if (streq(t, "tomorrow")) {
329	tm.tm_mday ++;
330	tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
331	goto finish;
332
333	} else if (t[0] == '+') {
334
335	r = parse_usec(t+1, &plus);
336	if (r < 0)
337	return r;
338
339	goto finish;
340	} else if (t[0] == '-') {
341
342	r = parse_usec(t+1, &minus);
343	if (r < 0)
344	return r;
345
346	goto finish;
347	}
348
349	copy = tm;
350	k = strptime(t, "%y-%m-%d %H:%M:%S", &tm);
351	if (k && *k == 0)
352	goto finish;
353
354	tm = copy;
355	k = strptime(t, "%Y-%m-%d %H:%M:%S", &tm);
356	if (k && *k == 0)
357	goto finish;
358
359	tm = copy;
360	k = strptime(t, "%y-%m-%d %H:%M", &tm);
361	if (k && *k == 0) {
362	tm.tm_sec = 0;
363	goto finish;
364	}
365
366	tm = copy;
367	k = strptime(t, "%Y-%m-%d %H:%M", &tm);
368	if (k && *k == 0) {
369	tm.tm_sec = 0;
370	goto finish;
371	}
372
373	tm = copy;
374	k = strptime(t, "%y-%m-%d", &tm);
375	if (k && *k == 0) {
376	tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
377	goto finish;
378	}
379
380	tm = copy;
381	k = strptime(t, "%Y-%m-%d", &tm);
382	if (k && *k == 0) {
383	tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
384	goto finish;
385	}
386
387	tm = copy;
388	k = strptime(t, "%H:%M:%S", &tm);
389	if (k && *k == 0)
390	goto finish;
391
392	tm = copy;
393	k = strptime(t, "%H:%M", &tm);
394	if (k && *k == 0) {
395	tm.tm_sec = 0;
396	goto finish;
397	}
398
399	return -EINVAL;
400
401	finish:
402	x = mktime(&tm);
403	if (x == (time_t) -1)
404	return -EINVAL;
405
406	ret = (usec_t) x * USEC_PER_SEC;
407
408	ret += plus;
409	if (ret > minus)
410	ret -= minus;
411	else
412	ret = 0;
413
414	*usec = ret;
415
416	return 0;
417	}
418
419	int parse_usec(const char t, usec_t usec) {
420	static const struct {
421	const char *suffix;
422	usec_t usec;
423	} table[] = {
424	{ "seconds", USEC_PER_SEC },
425	{ "second", USEC_PER_SEC },
426	{ "sec", USEC_PER_SEC },
427	{ "s", USEC_PER_SEC },
428	{ "minutes", USEC_PER_MINUTE },
429	{ "minute", USEC_PER_MINUTE },
430	{ "min", USEC_PER_MINUTE },
431	{ "months", USEC_PER_MONTH },
432	{ "month", USEC_PER_MONTH },
433	{ "msec", USEC_PER_MSEC },
434	{ "ms", USEC_PER_MSEC },
435	{ "m", USEC_PER_MINUTE },
436	{ "hours", USEC_PER_HOUR },
437	{ "hour", USEC_PER_HOUR },
438	{ "hr", USEC_PER_HOUR },
439	{ "h", USEC_PER_HOUR },
440	{ "days", USEC_PER_DAY },
441	{ "day", USEC_PER_DAY },
442	{ "d", USEC_PER_DAY },
443	{ "weeks", USEC_PER_WEEK },
444	{ "week", USEC_PER_WEEK },
445	{ "w", USEC_PER_WEEK },
446	{ "years", USEC_PER_YEAR },
447	{ "year", USEC_PER_YEAR },
448	{ "y", USEC_PER_YEAR },
449	{ "usec", 1ULL },
450	{ "us", 1ULL },
451	{ "", USEC_PER_SEC }, /* default is sec */
452	};
453
454	const char *p;
455	usec_t r = 0;
456
457	assert(t);
458	assert(usec);
459
460	p = t;
461	do {
462	long long l;
463	char *e;
464	unsigned i;
465
466	errno = 0;
467	l = strtoll(p, &e, 10);
468
469	if (errno != 0)
470	return -errno;
471
472	if (l < 0)
473	return -ERANGE;
474
475	if (e == p)
476	return -EINVAL;
477
478	e += strspn(e, WHITESPACE);
479
480	for (i = 0; i < ELEMENTSOF(table); i++)
481	if (startswith(e, table[i].suffix)) {
482	r += (usec_t) l * table[i].usec;
483	p = e + strlen(table[i].suffix);
484	break;
485	}
486
487	if (i >= ELEMENTSOF(table))
488	return -EINVAL;
489
490	} while (*p != 0);
491
492	*usec = r;
493
494	return 0;
495	}
496
497	int parse_nsec(const char t, nsec_t nsec) {
498	static const struct {
499	const char *suffix;
500	nsec_t nsec;
501	} table[] = {
502	{ "seconds", NSEC_PER_SEC },
503	{ "second", NSEC_PER_SEC },
504	{ "sec", NSEC_PER_SEC },
505	{ "s", NSEC_PER_SEC },
506	{ "minutes", NSEC_PER_MINUTE },
507	{ "minute", NSEC_PER_MINUTE },
508	{ "min", NSEC_PER_MINUTE },
509	{ "months", NSEC_PER_MONTH },
510	{ "month", NSEC_PER_MONTH },
511	{ "msec", NSEC_PER_MSEC },
512	{ "ms", NSEC_PER_MSEC },
513	{ "m", NSEC_PER_MINUTE },
514	{ "hours", NSEC_PER_HOUR },
515	{ "hour", NSEC_PER_HOUR },
516	{ "hr", NSEC_PER_HOUR },
517	{ "h", NSEC_PER_HOUR },
518	{ "days", NSEC_PER_DAY },
519	{ "day", NSEC_PER_DAY },
520	{ "d", NSEC_PER_DAY },
521	{ "weeks", NSEC_PER_WEEK },
522	{ "week", NSEC_PER_WEEK },
523	{ "w", NSEC_PER_WEEK },
524	{ "years", NSEC_PER_YEAR },
525	{ "year", NSEC_PER_YEAR },
526	{ "y", NSEC_PER_YEAR },
527	{ "usec", NSEC_PER_USEC },
528	{ "us", NSEC_PER_USEC },
529	{ "nsec", 1ULL },
530	{ "ns", 1ULL },
531	{ "", 1ULL }, /* default is nsec */
532	};
533
534	const char *p;
535	nsec_t r = 0;
536
537	assert(t);
538	assert(nsec);
539
540	p = t;
541	do {
542	long long l;
543	char *e;
544	unsigned i;
545
546	errno = 0;
547	l = strtoll(p, &e, 10);
548
549	if (errno != 0)
550	return -errno;
551
552	if (l < 0)
553	return -ERANGE;
554
555	if (e == p)
556	return -EINVAL;
557
558	e += strspn(e, WHITESPACE);
559
560	for (i = 0; i < ELEMENTSOF(table); i++)
561	if (startswith(e, table[i].suffix)) {
562	r += (nsec_t) l * table[i].nsec;
563	p = e + strlen(table[i].suffix);
564	break;
565	}
566
567	if (i >= ELEMENTSOF(table))
568	return -EINVAL;
569
570	} while (*p != 0);
571
572	*nsec = r;
573
574	return 0;
575	}