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