chiark / gitweb /
34061fea9e51785eb974f2671cf6f73b3134956c
[elogind.git] / src / basic / time-util.c
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 <string.h>
23 #include <sys/timerfd.h>
24 #include <sys/timex.h>
25
26 #include "alloc-util.h"
27 #include "fd-util.h"
28 #include "fileio.h"
29 #include "fs-util.h"
30 #include "parse-util.h"
31 #include "path-util.h"
32 #include "string-util.h"
33 #include "strv.h"
34 #include "time-util.h"
35 #include "util.h"
36
37 usec_t now(clockid_t clock_id) {
38         struct timespec ts;
39
40         assert_se(clock_gettime(clock_id, &ts) == 0);
41
42         return timespec_load(&ts);
43 }
44
45 #if 0 /// UNNEEDED by elogind
46 nsec_t now_nsec(clockid_t clock_id) {
47         struct timespec ts;
48
49         assert_se(clock_gettime(clock_id, &ts) == 0);
50
51         return timespec_load_nsec(&ts);
52 }
53 #endif // 0
54
55 dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
56         assert(ts);
57
58         ts->realtime = now(CLOCK_REALTIME);
59         ts->monotonic = now(CLOCK_MONOTONIC);
60
61         return ts;
62 }
63
64 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
65         int64_t delta;
66         assert(ts);
67
68         if (u == USEC_INFINITY || u <= 0) {
69                 ts->realtime = ts->monotonic = u;
70                 return ts;
71         }
72
73         ts->realtime = u;
74
75         delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
76         ts->monotonic = now(CLOCK_MONOTONIC);
77
78         if ((int64_t) ts->monotonic > delta)
79                 ts->monotonic -= delta;
80         else
81                 ts->monotonic = 0;
82
83         return ts;
84 }
85
86 #if 0 /// UNNEEDED by elogind
87 dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u) {
88         int64_t delta;
89         assert(ts);
90
91         if (u == USEC_INFINITY) {
92                 ts->realtime = ts->monotonic = USEC_INFINITY;
93                 return ts;
94         }
95
96         ts->monotonic = u;
97         delta = (int64_t) now(CLOCK_MONOTONIC) - (int64_t) u;
98
99         ts->realtime = now(CLOCK_REALTIME);
100         if ((int64_t) ts->realtime > delta)
101                 ts->realtime -= delta;
102         else
103                 ts->realtime = 0;
104
105         return ts;
106 }
107
108 dual_timestamp* dual_timestamp_from_boottime_or_monotonic(dual_timestamp *ts, usec_t u) {
109         int64_t delta;
110
111         if (u == USEC_INFINITY) {
112                 ts->realtime = ts->monotonic = USEC_INFINITY;
113                 return ts;
114         }
115         ts->realtime = now(CLOCK_REALTIME);
116         ts->monotonic = now(CLOCK_MONOTONIC);
117
118         delta = (int64_t) now(clock_boottime_or_monotonic()) - (int64_t) u;
119
120         if ((int64_t) ts->realtime > delta)
121                 ts->realtime -= delta;
122         else
123                 ts->realtime = 0;
124
125         if ((int64_t) ts->monotonic > delta)
126                 ts->monotonic -= delta;
127         else
128                 ts->monotonic = 0;
129
130         return ts;
131 }
132 #endif // 0
133
134 usec_t timespec_load(const struct timespec *ts) {
135         assert(ts);
136
137         if (ts->tv_sec == (time_t) -1 &&
138             ts->tv_nsec == (long) -1)
139                 return USEC_INFINITY;
140
141         if ((usec_t) ts->tv_sec > (UINT64_MAX - (ts->tv_nsec / NSEC_PER_USEC)) / USEC_PER_SEC)
142                 return USEC_INFINITY;
143
144         return
145                 (usec_t) ts->tv_sec * USEC_PER_SEC +
146                 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
147 }
148
149 nsec_t timespec_load_nsec(const struct timespec *ts) {
150         assert(ts);
151
152         if (ts->tv_sec == (time_t) -1 &&
153             ts->tv_nsec == (long) -1)
154                 return NSEC_INFINITY;
155
156         return
157                 (nsec_t) ts->tv_sec * NSEC_PER_SEC +
158                 (nsec_t) ts->tv_nsec;
159 }
160
161 struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
162         assert(ts);
163
164         if (u == USEC_INFINITY) {
165                 ts->tv_sec = (time_t) -1;
166                 ts->tv_nsec = (long) -1;
167                 return ts;
168         }
169
170         ts->tv_sec = (time_t) (u / USEC_PER_SEC);
171         ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
172
173         return ts;
174 }
175
176 usec_t timeval_load(const struct timeval *tv) {
177         assert(tv);
178
179         if (tv->tv_sec == (time_t) -1 &&
180             tv->tv_usec == (suseconds_t) -1)
181                 return USEC_INFINITY;
182
183         if ((usec_t) tv->tv_sec > (UINT64_MAX - tv->tv_usec) / USEC_PER_SEC)
184                 return USEC_INFINITY;
185
186         return
187                 (usec_t) tv->tv_sec * USEC_PER_SEC +
188                 (usec_t) tv->tv_usec;
189 }
190
191 struct timeval *timeval_store(struct timeval *tv, usec_t u) {
192         assert(tv);
193
194         if (u == USEC_INFINITY) {
195                 tv->tv_sec = (time_t) -1;
196                 tv->tv_usec = (suseconds_t) -1;
197         } else {
198                 tv->tv_sec = (time_t) (u / USEC_PER_SEC);
199                 tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
200         }
201
202         return tv;
203 }
204
205 static char *format_timestamp_internal(char *buf, size_t l, usec_t t, bool utc) {
206         struct tm tm;
207         time_t sec;
208
209         assert(buf);
210         assert(l > 0);
211
212         if (t <= 0 || t == USEC_INFINITY)
213                 return NULL;
214
215         sec = (time_t) (t / USEC_PER_SEC);
216         localtime_or_gmtime_r(&sec, &tm, utc);
217
218         if (strftime(buf, l, "%a %Y-%m-%d %H:%M:%S %Z", &tm) <= 0)
219                 return NULL;
220
221         return buf;
222 }
223
224 char *format_timestamp(char *buf, size_t l, usec_t t) {
225         return format_timestamp_internal(buf, l, t, false);
226 }
227
228 #if 0 /// UNNEEDED by elogind
229 char *format_timestamp_utc(char *buf, size_t l, usec_t t) {
230         return format_timestamp_internal(buf, l, t, true);
231 }
232 #endif // 0
233
234 static char *format_timestamp_internal_us(char *buf, size_t l, usec_t t, bool utc) {
235         struct tm tm;
236         time_t sec;
237
238         assert(buf);
239         assert(l > 0);
240
241         if (t <= 0 || t == USEC_INFINITY)
242                 return NULL;
243
244         sec = (time_t) (t / USEC_PER_SEC);
245         localtime_or_gmtime_r(&sec, &tm, utc);
246
247         if (strftime(buf, l, "%a %Y-%m-%d %H:%M:%S", &tm) <= 0)
248                 return NULL;
249         snprintf(buf + strlen(buf), l - strlen(buf), ".%06llu", (unsigned long long) (t % USEC_PER_SEC));
250         if (strftime(buf + strlen(buf), l - strlen(buf), " %Z", &tm) <= 0)
251                 return NULL;
252
253         return buf;
254 }
255
256 char *format_timestamp_us(char *buf, size_t l, usec_t t) {
257         return format_timestamp_internal_us(buf, l, t, false);
258 }
259
260 #if 0 /// UNNEEDED by elogind
261 char *format_timestamp_us_utc(char *buf, size_t l, usec_t t) {
262         return format_timestamp_internal_us(buf, l, t, true);
263 }
264 #endif // 0
265
266 char *format_timestamp_relative(char *buf, size_t l, usec_t t) {
267         const char *s;
268         usec_t n, d;
269
270         if (t <= 0 || t == USEC_INFINITY)
271                 return NULL;
272
273         n = now(CLOCK_REALTIME);
274         if (n > t) {
275                 d = n - t;
276                 s = "ago";
277         } else {
278                 d = t - n;
279                 s = "left";
280         }
281
282         if (d >= USEC_PER_YEAR)
283                 snprintf(buf, l, USEC_FMT " years " USEC_FMT " months %s",
284                          d / USEC_PER_YEAR,
285                          (d % USEC_PER_YEAR) / USEC_PER_MONTH, s);
286         else if (d >= USEC_PER_MONTH)
287                 snprintf(buf, l, USEC_FMT " months " USEC_FMT " days %s",
288                          d / USEC_PER_MONTH,
289                          (d % USEC_PER_MONTH) / USEC_PER_DAY, s);
290         else if (d >= USEC_PER_WEEK)
291                 snprintf(buf, l, USEC_FMT " weeks " USEC_FMT " days %s",
292                          d / USEC_PER_WEEK,
293                          (d % USEC_PER_WEEK) / USEC_PER_DAY, s);
294         else if (d >= 2*USEC_PER_DAY)
295                 snprintf(buf, l, USEC_FMT " days %s", d / USEC_PER_DAY, s);
296         else if (d >= 25*USEC_PER_HOUR)
297                 snprintf(buf, l, "1 day " USEC_FMT "h %s",
298                          (d - USEC_PER_DAY) / USEC_PER_HOUR, s);
299         else if (d >= 6*USEC_PER_HOUR)
300                 snprintf(buf, l, USEC_FMT "h %s",
301                          d / USEC_PER_HOUR, s);
302         else if (d >= USEC_PER_HOUR)
303                 snprintf(buf, l, USEC_FMT "h " USEC_FMT "min %s",
304                          d / USEC_PER_HOUR,
305                          (d % USEC_PER_HOUR) / USEC_PER_MINUTE, s);
306         else if (d >= 5*USEC_PER_MINUTE)
307                 snprintf(buf, l, USEC_FMT "min %s",
308                          d / USEC_PER_MINUTE, s);
309         else if (d >= USEC_PER_MINUTE)
310                 snprintf(buf, l, USEC_FMT "min " USEC_FMT "s %s",
311                          d / USEC_PER_MINUTE,
312                          (d % USEC_PER_MINUTE) / USEC_PER_SEC, s);
313         else if (d >= USEC_PER_SEC)
314                 snprintf(buf, l, USEC_FMT "s %s",
315                          d / USEC_PER_SEC, s);
316         else if (d >= USEC_PER_MSEC)
317                 snprintf(buf, l, USEC_FMT "ms %s",
318                          d / USEC_PER_MSEC, s);
319         else if (d > 0)
320                 snprintf(buf, l, USEC_FMT"us %s",
321                          d, s);
322         else
323                 snprintf(buf, l, "now");
324
325         buf[l-1] = 0;
326         return buf;
327 }
328
329 char *format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy) {
330         static const struct {
331                 const char *suffix;
332                 usec_t usec;
333         } table[] = {
334                 { "y", USEC_PER_YEAR },
335                 { "month", USEC_PER_MONTH },
336                 { "w", USEC_PER_WEEK },
337                 { "d", USEC_PER_DAY },
338                 { "h", USEC_PER_HOUR },
339                 { "min", USEC_PER_MINUTE },
340                 { "s", USEC_PER_SEC },
341                 { "ms", USEC_PER_MSEC },
342                 { "us", 1 },
343         };
344
345         unsigned i;
346         char *p = buf;
347         bool something = false;
348
349         assert(buf);
350         assert(l > 0);
351
352         if (t == USEC_INFINITY) {
353                 strncpy(p, "infinity", l-1);
354                 p[l-1] = 0;
355                 return p;
356         }
357
358         if (t <= 0) {
359                 strncpy(p, "0", l-1);
360                 p[l-1] = 0;
361                 return p;
362         }
363
364         /* The result of this function can be parsed with parse_sec */
365
366         for (i = 0; i < ELEMENTSOF(table); i++) {
367                 int k = 0;
368                 size_t n;
369                 bool done = false;
370                 usec_t a, b;
371
372                 if (t <= 0)
373                         break;
374
375                 if (t < accuracy && something)
376                         break;
377
378                 if (t < table[i].usec)
379                         continue;
380
381                 if (l <= 1)
382                         break;
383
384                 a = t / table[i].usec;
385                 b = t % table[i].usec;
386
387                 /* Let's see if we should shows this in dot notation */
388                 if (t < USEC_PER_MINUTE && b > 0) {
389                         usec_t cc;
390                         int j;
391
392                         j = 0;
393                         for (cc = table[i].usec; cc > 1; cc /= 10)
394                                 j++;
395
396                         for (cc = accuracy; cc > 1; cc /= 10) {
397                                 b /= 10;
398                                 j--;
399                         }
400
401                         if (j > 0) {
402                                 k = snprintf(p, l,
403                                              "%s"USEC_FMT".%0*llu%s",
404                                              p > buf ? " " : "",
405                                              a,
406                                              j,
407                                              (unsigned long long) b,
408                                              table[i].suffix);
409
410                                 t = 0;
411                                 done = true;
412                         }
413                 }
414
415                 /* No? Then let's show it normally */
416                 if (!done) {
417                         k = snprintf(p, l,
418                                      "%s"USEC_FMT"%s",
419                                      p > buf ? " " : "",
420                                      a,
421                                      table[i].suffix);
422
423                         t = b;
424                 }
425
426                 n = MIN((size_t) k, l);
427
428                 l -= n;
429                 p += n;
430
431                 something = true;
432         }
433
434         *p = 0;
435
436         return buf;
437 }
438
439 #if 0 /// UNNEEDED by elogind
440 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {
441
442         assert(f);
443         assert(name);
444         assert(t);
445
446         if (!dual_timestamp_is_set(t))
447                 return;
448
449         fprintf(f, "%s="USEC_FMT" "USEC_FMT"\n",
450                 name,
451                 t->realtime,
452                 t->monotonic);
453 }
454
455 int dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
456         unsigned long long a, b;
457
458         assert(value);
459         assert(t);
460
461         if (sscanf(value, "%llu %llu", &a, &b) != 2) {
462                 log_debug("Failed to parse finish timestamp value %s.", value);
463                 return -EINVAL;
464         }
465
466         t->realtime = a;
467         t->monotonic = b;
468
469         return 0;
470 }
471
472 int parse_timestamp(const char *t, usec_t *usec) {
473         static const struct {
474                 const char *name;
475                 const int nr;
476         } day_nr[] = {
477                 { "Sunday",    0 },
478                 { "Sun",       0 },
479                 { "Monday",    1 },
480                 { "Mon",       1 },
481                 { "Tuesday",   2 },
482                 { "Tue",       2 },
483                 { "Wednesday", 3 },
484                 { "Wed",       3 },
485                 { "Thursday",  4 },
486                 { "Thu",       4 },
487                 { "Friday",    5 },
488                 { "Fri",       5 },
489                 { "Saturday",  6 },
490                 { "Sat",       6 },
491         };
492
493         const char *k;
494         const char *utc;
495         struct tm tm, copy;
496         time_t x;
497         usec_t x_usec, plus = 0, minus = 0, ret;
498         int r, weekday = -1;
499         unsigned i;
500
501         /*
502          * Allowed syntaxes:
503          *
504          *   2012-09-22 16:34:22
505          *   2012-09-22 16:34     (seconds will be set to 0)
506          *   2012-09-22           (time will be set to 00:00:00)
507          *   16:34:22             (date will be set to today)
508          *   16:34                (date will be set to today, seconds to 0)
509          *   now
510          *   yesterday            (time is set to 00:00:00)
511          *   today                (time is set to 00:00:00)
512          *   tomorrow             (time is set to 00:00:00)
513          *   +5min
514          *   -5days
515          *   @2147483647          (seconds since epoch)
516          *
517          */
518
519         assert(t);
520         assert(usec);
521
522         if (t[0] == '@')
523                 return parse_sec(t + 1, usec);
524
525         ret = now(CLOCK_REALTIME);
526
527         if (streq(t, "now"))
528                 goto finish;
529
530         else if (t[0] == '+') {
531                 r = parse_sec(t+1, &plus);
532                 if (r < 0)
533                         return r;
534
535                 goto finish;
536
537         } else if (t[0] == '-') {
538                 r = parse_sec(t+1, &minus);
539                 if (r < 0)
540                         return r;
541
542                 goto finish;
543
544         } else if ((k = endswith(t, " ago"))) {
545                 t = strndupa(t, k - t);
546
547                 r = parse_sec(t, &minus);
548                 if (r < 0)
549                         return r;
550
551                 goto finish;
552
553         } else if ((k = endswith(t, " left"))) {
554                 t = strndupa(t, k - t);
555
556                 r = parse_sec(t, &plus);
557                 if (r < 0)
558                         return r;
559
560                 goto finish;
561         }
562
563         utc = endswith_no_case(t, " UTC");
564         if (utc)
565                 t = strndupa(t, utc - t);
566
567         x = ret / USEC_PER_SEC;
568         x_usec = 0;
569
570         assert_se(localtime_or_gmtime_r(&x, &tm, utc));
571         tm.tm_isdst = -1;
572
573         if (streq(t, "today")) {
574                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
575                 goto from_tm;
576
577         } else if (streq(t, "yesterday")) {
578                 tm.tm_mday --;
579                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
580                 goto from_tm;
581
582         } else if (streq(t, "tomorrow")) {
583                 tm.tm_mday ++;
584                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
585                 goto from_tm;
586         }
587
588
589         for (i = 0; i < ELEMENTSOF(day_nr); i++) {
590                 size_t skip;
591
592                 if (!startswith_no_case(t, day_nr[i].name))
593                         continue;
594
595                 skip = strlen(day_nr[i].name);
596                 if (t[skip] != ' ')
597                         continue;
598
599                 weekday = day_nr[i].nr;
600                 t += skip + 1;
601                 break;
602         }
603
604         copy = tm;
605         k = strptime(t, "%y-%m-%d %H:%M:%S", &tm);
606         if (k) {
607                 if (*k == '.')
608                         goto parse_usec;
609                 else if (*k == 0)
610                         goto from_tm;
611         }
612
613         tm = copy;
614         k = strptime(t, "%Y-%m-%d %H:%M:%S", &tm);
615         if (k) {
616                 if (*k == '.')
617                         goto parse_usec;
618                 else if (*k == 0)
619                         goto from_tm;
620         }
621
622         tm = copy;
623         k = strptime(t, "%y-%m-%d %H:%M", &tm);
624         if (k && *k == 0) {
625                 tm.tm_sec = 0;
626                 goto from_tm;
627         }
628
629         tm = copy;
630         k = strptime(t, "%Y-%m-%d %H:%M", &tm);
631         if (k && *k == 0) {
632                 tm.tm_sec = 0;
633                 goto from_tm;
634         }
635
636         tm = copy;
637         k = strptime(t, "%y-%m-%d", &tm);
638         if (k && *k == 0) {
639                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
640                 goto from_tm;
641         }
642
643         tm = copy;
644         k = strptime(t, "%Y-%m-%d", &tm);
645         if (k && *k == 0) {
646                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
647                 goto from_tm;
648         }
649
650         tm = copy;
651         k = strptime(t, "%H:%M:%S", &tm);
652         if (k) {
653                 if (*k == '.')
654                         goto parse_usec;
655                 else if (*k == 0)
656                         goto from_tm;
657         }
658
659         tm = copy;
660         k = strptime(t, "%H:%M", &tm);
661         if (k && *k == 0) {
662                 tm.tm_sec = 0;
663                 goto from_tm;
664         }
665
666         return -EINVAL;
667
668 parse_usec:
669         {
670                 unsigned add;
671
672                 k++;
673                 r = parse_fractional_part_u(&k, 6, &add);
674                 if (r < 0)
675                         return -EINVAL;
676
677                 if (*k)
678                         return -EINVAL;
679
680                 x_usec = add;
681
682         }
683
684 from_tm:
685         x = mktime_or_timegm(&tm, utc);
686         if (x == (time_t) -1)
687                 return -EINVAL;
688
689         if (weekday >= 0 && tm.tm_wday != weekday)
690                 return -EINVAL;
691
692         ret = (usec_t) x * USEC_PER_SEC + x_usec;
693
694 finish:
695         ret += plus;
696         if (ret > minus)
697                 ret -= minus;
698         else
699                 ret = 0;
700
701         *usec = ret;
702
703         return 0;
704 }
705 #endif // 0
706
707 int parse_time(const char *t, usec_t *usec, usec_t default_unit) {
708
709         static const struct {
710                 const char *suffix;
711                 usec_t usec;
712         } table[] = {
713                 { "seconds", USEC_PER_SEC },
714                 { "second", USEC_PER_SEC },
715                 { "sec", USEC_PER_SEC },
716                 { "s", USEC_PER_SEC },
717                 { "minutes", USEC_PER_MINUTE },
718                 { "minute", USEC_PER_MINUTE },
719                 { "min", USEC_PER_MINUTE },
720                 { "months", USEC_PER_MONTH },
721                 { "month", USEC_PER_MONTH },
722                 { "M",       USEC_PER_MONTH  },
723                 { "msec", USEC_PER_MSEC },
724                 { "ms", USEC_PER_MSEC },
725                 { "m", USEC_PER_MINUTE },
726                 { "hours", USEC_PER_HOUR },
727                 { "hour", USEC_PER_HOUR },
728                 { "hr", USEC_PER_HOUR },
729                 { "h", USEC_PER_HOUR },
730                 { "days", USEC_PER_DAY },
731                 { "day", USEC_PER_DAY },
732                 { "d", USEC_PER_DAY },
733                 { "weeks", USEC_PER_WEEK },
734                 { "week", USEC_PER_WEEK },
735                 { "w", USEC_PER_WEEK },
736                 { "years", USEC_PER_YEAR },
737                 { "year", USEC_PER_YEAR },
738                 { "y", USEC_PER_YEAR },
739                 { "usec", 1ULL },
740                 { "us", 1ULL },
741         };
742
743         const char *p, *s;
744         usec_t r = 0;
745         bool something = false;
746
747         assert(t);
748         assert(usec);
749         assert(default_unit > 0);
750
751         p = t;
752
753         p += strspn(p, WHITESPACE);
754         s = startswith(p, "infinity");
755         if (s) {
756                 s += strspn(s, WHITESPACE);
757                 if (*s != 0)
758                         return -EINVAL;
759
760                 *usec = USEC_INFINITY;
761                 return 0;
762         }
763
764         for (;;) {
765                 long long l, z = 0;
766                 char *e;
767                 unsigned i, n = 0;
768                 usec_t multiplier, k;
769
770                 p += strspn(p, WHITESPACE);
771
772                 if (*p == 0) {
773                         if (!something)
774                                 return -EINVAL;
775
776                         break;
777                 }
778
779                 errno = 0;
780                 l = strtoll(p, &e, 10);
781
782                 if (errno > 0)
783                         return -errno;
784
785                 if (l < 0)
786                         return -ERANGE;
787
788                 if (*e == '.') {
789                         char *b = e + 1;
790
791                         errno = 0;
792                         z = strtoll(b, &e, 10);
793                         if (errno > 0)
794                                 return -errno;
795
796                         if (z < 0)
797                                 return -ERANGE;
798
799                         if (e == b)
800                                 return -EINVAL;
801
802                         n = e - b;
803
804                 } else if (e == p)
805                         return -EINVAL;
806
807                 e += strspn(e, WHITESPACE);
808
809                 for (i = 0; i < ELEMENTSOF(table); i++)
810                         if (startswith(e, table[i].suffix)) {
811                                 multiplier = table[i].usec;
812                                 p = e + strlen(table[i].suffix);
813                                 break;
814                         }
815
816                 if (i >= ELEMENTSOF(table)) {
817                         multiplier = default_unit;
818                         p = e;
819                 }
820
821                 something = true;
822
823                 k = (usec_t) z * multiplier;
824
825                 for (; n > 0; n--)
826                         k /= 10;
827
828                 r += (usec_t) l * multiplier + k;
829         }
830
831         *usec = r;
832
833         return 0;
834 }
835
836 int parse_sec(const char *t, usec_t *usec) {
837         return parse_time(t, usec, USEC_PER_SEC);
838 }
839
840 #if 0 /// UNNEEDED by elogind
841 int parse_nsec(const char *t, nsec_t *nsec) {
842         static const struct {
843                 const char *suffix;
844                 nsec_t nsec;
845         } table[] = {
846                 { "seconds", NSEC_PER_SEC },
847                 { "second", NSEC_PER_SEC },
848                 { "sec", NSEC_PER_SEC },
849                 { "s", NSEC_PER_SEC },
850                 { "minutes", NSEC_PER_MINUTE },
851                 { "minute", NSEC_PER_MINUTE },
852                 { "min", NSEC_PER_MINUTE },
853                 { "months", NSEC_PER_MONTH },
854                 { "month", NSEC_PER_MONTH },
855                 { "msec", NSEC_PER_MSEC },
856                 { "ms", NSEC_PER_MSEC },
857                 { "m", NSEC_PER_MINUTE },
858                 { "hours", NSEC_PER_HOUR },
859                 { "hour", NSEC_PER_HOUR },
860                 { "hr", NSEC_PER_HOUR },
861                 { "h", NSEC_PER_HOUR },
862                 { "days", NSEC_PER_DAY },
863                 { "day", NSEC_PER_DAY },
864                 { "d", NSEC_PER_DAY },
865                 { "weeks", NSEC_PER_WEEK },
866                 { "week", NSEC_PER_WEEK },
867                 { "w", NSEC_PER_WEEK },
868                 { "years", NSEC_PER_YEAR },
869                 { "year", NSEC_PER_YEAR },
870                 { "y", NSEC_PER_YEAR },
871                 { "usec", NSEC_PER_USEC },
872                 { "us", NSEC_PER_USEC },
873                 { "nsec", 1ULL },
874                 { "ns", 1ULL },
875                 { "", 1ULL }, /* default is nsec */
876         };
877
878         const char *p, *s;
879         nsec_t r = 0;
880         bool something = false;
881
882         assert(t);
883         assert(nsec);
884
885         p = t;
886
887         p += strspn(p, WHITESPACE);
888         s = startswith(p, "infinity");
889         if (s) {
890                 s += strspn(s, WHITESPACE);
891                 if (*s != 0)
892                         return -EINVAL;
893
894                 *nsec = NSEC_INFINITY;
895                 return 0;
896         }
897
898         for (;;) {
899                 long long l, z = 0;
900                 char *e;
901                 unsigned i, n = 0;
902
903                 p += strspn(p, WHITESPACE);
904
905                 if (*p == 0) {
906                         if (!something)
907                                 return -EINVAL;
908
909                         break;
910                 }
911
912                 errno = 0;
913                 l = strtoll(p, &e, 10);
914
915                 if (errno > 0)
916                         return -errno;
917
918                 if (l < 0)
919                         return -ERANGE;
920
921                 if (*e == '.') {
922                         char *b = e + 1;
923
924                         errno = 0;
925                         z = strtoll(b, &e, 10);
926                         if (errno > 0)
927                                 return -errno;
928
929                         if (z < 0)
930                                 return -ERANGE;
931
932                         if (e == b)
933                                 return -EINVAL;
934
935                         n = e - b;
936
937                 } else if (e == p)
938                         return -EINVAL;
939
940                 e += strspn(e, WHITESPACE);
941
942                 for (i = 0; i < ELEMENTSOF(table); i++)
943                         if (startswith(e, table[i].suffix)) {
944                                 nsec_t k = (nsec_t) z * table[i].nsec;
945
946                                 for (; n > 0; n--)
947                                         k /= 10;
948
949                                 r += (nsec_t) l * table[i].nsec + k;
950                                 p = e + strlen(table[i].suffix);
951
952                                 something = true;
953                                 break;
954                         }
955
956                 if (i >= ELEMENTSOF(table))
957                         return -EINVAL;
958
959         }
960
961         *nsec = r;
962
963         return 0;
964 }
965
966 bool ntp_synced(void) {
967         struct timex txc = {};
968
969         if (adjtimex(&txc) < 0)
970                 return false;
971
972         if (txc.status & STA_UNSYNC)
973                 return false;
974
975         return true;
976 }
977
978 int get_timezones(char ***ret) {
979         _cleanup_fclose_ FILE *f = NULL;
980         _cleanup_strv_free_ char **zones = NULL;
981         size_t n_zones = 0, n_allocated = 0;
982
983         assert(ret);
984
985         zones = strv_new("UTC", NULL);
986         if (!zones)
987                 return -ENOMEM;
988
989         n_allocated = 2;
990         n_zones = 1;
991
992         f = fopen("/usr/share/zoneinfo/zone.tab", "re");
993         if (f) {
994                 char l[LINE_MAX];
995
996                 FOREACH_LINE(l, f, return -errno) {
997                         char *p, *w;
998                         size_t k;
999
1000                         p = strstrip(l);
1001
1002                         if (isempty(p) || *p == '#')
1003                                 continue;
1004
1005                         /* Skip over country code */
1006                         p += strcspn(p, WHITESPACE);
1007                         p += strspn(p, WHITESPACE);
1008
1009                         /* Skip over coordinates */
1010                         p += strcspn(p, WHITESPACE);
1011                         p += strspn(p, WHITESPACE);
1012
1013                         /* Found timezone name */
1014                         k = strcspn(p, WHITESPACE);
1015                         if (k <= 0)
1016                                 continue;
1017
1018                         w = strndup(p, k);
1019                         if (!w)
1020                                 return -ENOMEM;
1021
1022                         if (!GREEDY_REALLOC(zones, n_allocated, n_zones + 2)) {
1023                                 free(w);
1024                                 return -ENOMEM;
1025                         }
1026
1027                         zones[n_zones++] = w;
1028                         zones[n_zones] = NULL;
1029                 }
1030
1031                 strv_sort(zones);
1032
1033         } else if (errno != ENOENT)
1034                 return -errno;
1035
1036         *ret = zones;
1037         zones = NULL;
1038
1039         return 0;
1040 }
1041
1042 bool timezone_is_valid(const char *name) {
1043         bool slash = false;
1044         const char *p, *t;
1045         struct stat st;
1046
1047         if (isempty(name))
1048                 return false;
1049
1050         if (name[0] == '/')
1051                 return false;
1052
1053         for (p = name; *p; p++) {
1054                 if (!(*p >= '0' && *p <= '9') &&
1055                     !(*p >= 'a' && *p <= 'z') &&
1056                     !(*p >= 'A' && *p <= 'Z') &&
1057                     !(*p == '-' || *p == '_' || *p == '+' || *p == '/'))
1058                         return false;
1059
1060                 if (*p == '/') {
1061
1062                         if (slash)
1063                                 return false;
1064
1065                         slash = true;
1066                 } else
1067                         slash = false;
1068         }
1069
1070         if (slash)
1071                 return false;
1072
1073         t = strjoina("/usr/share/zoneinfo/", name);
1074         if (stat(t, &st) < 0)
1075                 return false;
1076
1077         if (!S_ISREG(st.st_mode))
1078                 return false;
1079
1080         return true;
1081 }
1082
1083 clockid_t clock_boottime_or_monotonic(void) {
1084         static clockid_t clock = -1;
1085         int fd;
1086
1087         if (clock != -1)
1088                 return clock;
1089
1090         fd = timerfd_create(CLOCK_BOOTTIME, TFD_NONBLOCK|TFD_CLOEXEC);
1091         if (fd < 0)
1092                 clock = CLOCK_MONOTONIC;
1093         else {
1094                 safe_close(fd);
1095                 clock = CLOCK_BOOTTIME;
1096         }
1097
1098         return clock;
1099 }
1100
1101 int get_timezone(char **tz) {
1102         _cleanup_free_ char *t = NULL;
1103         const char *e;
1104         char *z;
1105         int r;
1106
1107         r = readlink_malloc("/etc/localtime", &t);
1108         if (r < 0)
1109                 return r; /* returns EINVAL if not a symlink */
1110
1111         e = path_startswith(t, "/usr/share/zoneinfo/");
1112         if (!e)
1113                 e = path_startswith(t, "../usr/share/zoneinfo/");
1114         if (!e)
1115                 return -EINVAL;
1116
1117         if (!timezone_is_valid(e))
1118                 return -EINVAL;
1119
1120         z = strdup(e);
1121         if (!z)
1122                 return -ENOMEM;
1123
1124         *tz = z;
1125         return 0;
1126 }
1127
1128 time_t mktime_or_timegm(struct tm *tm, bool utc) {
1129         return utc ? timegm(tm) : mktime(tm);
1130 }
1131 #endif // 0
1132
1133 struct tm *localtime_or_gmtime_r(const time_t *t, struct tm *tm, bool utc) {
1134         return utc ? gmtime_r(t, tm) : localtime_r(t, tm);
1135 }
1136
1137 #if 0 /// UNNEEDED by elogind
1138 unsigned long usec_to_jiffies(usec_t u) {
1139         static thread_local unsigned long hz = 0;
1140         long r;
1141
1142         if (hz == 0) {
1143                 r = sysconf(_SC_CLK_TCK);
1144
1145                 assert(r > 0);
1146                 hz = (unsigned long) r;
1147         }
1148
1149         return DIV_ROUND_UP(u , USEC_PER_SEC / hz);
1150 }
1151 #endif // 0