src/basic/time-util.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright 2010 Lennart Poettering
   5
   6   systemd is free software; you can redistribute it and/or modify it
   7   under the terms of the GNU Lesser General Public License as published by
   8   the Free Software Foundation; either version 2.1 of the License, or
   9   (at your option) any later version.
  10
  11   systemd is distributed in the hope that it will be useful, but
  12   WITHOUT ANY WARRANTY; without even the implied warranty of
  13   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  14   Lesser General Public License for more details.
  15
  16   You should have received a copy of the GNU Lesser General Public License
  17   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  18 ***/
  19
  20 #include <errno.h>
  21 #include <limits.h>
  22 #include <stdlib.h>
  23 #include <string.h>
  24 #include <sys/stat.h>
  25 #include <sys/time.h>
  26 #include <sys/timerfd.h>
  27 #include <sys/timex.h>
  28 #include <sys/types.h>
  29 #include <unistd.h>
  30
  31 #include "alloc-util.h"
  32 #include "fd-util.h"
  33 #include "fileio.h"
  34 #include "fs-util.h"
  35 #include "log.h"
  36 #include "macro.h"
  37 #include "parse-util.h"
  38 #include "path-util.h"
  39 #include "string-util.h"
  40 #include "strv.h"
  41 #include "time-util.h"
  42
  43 static clockid_t map_clock_id(clockid_t c) {
  44
  45         /* Some more exotic archs (s390, ppc, …) lack the "ALARM" flavour of the clocks. Thus, clock_gettime() will
  46          * fail for them. Since they are essentially the same as their non-ALARM pendants (their only difference is
  47          * when timers are set on them), let's just map them accordingly. This way, we can get the correct time even on
  48          * those archs. */
  49
  50         switch (c) {
  51
  52         case CLOCK_BOOTTIME_ALARM:
  53                 return CLOCK_BOOTTIME;
  54
  55         case CLOCK_REALTIME_ALARM:
  56                 return CLOCK_REALTIME;
  57
  58         default:
  59                 return c;
  60         }
  61 }
  62
  63 usec_t now(clockid_t clock_id) {
  64         struct timespec ts;
  65
  66         assert_se(clock_gettime(map_clock_id(clock_id), &ts) == 0);
  67
  68         return timespec_load(&ts);
  69 }
  70
  71 #if 0 /// UNNEEDED by elogind
  72 nsec_t now_nsec(clockid_t clock_id) {
  73         struct timespec ts;
  74
  75         assert_se(clock_gettime(map_clock_id(clock_id), &ts) == 0);
  76
  77         return timespec_load_nsec(&ts);
  78 }
  79 #endif // 0
  80
  81 dual_timestamp* dual_timestamp_get(dual_timestamp *ts) {
  82         assert(ts);
  83
  84         ts->realtime = now(CLOCK_REALTIME);
  85         ts->monotonic = now(CLOCK_MONOTONIC);
  86
  87         return ts;
  88 }
  89
  90 triple_timestamp* triple_timestamp_get(triple_timestamp *ts) {
  91         assert(ts);
  92
  93         ts->realtime = now(CLOCK_REALTIME);
  94         ts->monotonic = now(CLOCK_MONOTONIC);
  95         ts->boottime = clock_boottime_supported() ? now(CLOCK_BOOTTIME) : USEC_INFINITY;
  96
  97         return ts;
  98 }
  99
 100 dual_timestamp* dual_timestamp_from_realtime(dual_timestamp *ts, usec_t u) {
 101         int64_t delta;
 102         assert(ts);
 103
 104         if (u == USEC_INFINITY || u <= 0) {
 105                 ts->realtime = ts->monotonic = u;
 106                 return ts;
 107         }
 108
 109         ts->realtime = u;
 110
 111         delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
 112         ts->monotonic = usec_sub_signed(now(CLOCK_MONOTONIC), delta);
 113
 114         return ts;
 115 }
 116
 117 #if 0 /// UNNEEDED by elogind
 118 triple_timestamp* triple_timestamp_from_realtime(triple_timestamp *ts, usec_t u) {
 119         int64_t delta;
 120
 121         assert(ts);
 122
 123         if (u == USEC_INFINITY || u <= 0) {
 124                 ts->realtime = ts->monotonic = ts->boottime = u;
 125                 return ts;
 126         }
 127
 128         ts->realtime = u;
 129         delta = (int64_t) now(CLOCK_REALTIME) - (int64_t) u;
 130         ts->monotonic = usec_sub_signed(now(CLOCK_MONOTONIC), delta);
 131         ts->boottime = clock_boottime_supported() ? usec_sub_signed(now(CLOCK_BOOTTIME), delta) : USEC_INFINITY;
 132
 133         return ts;
 134 }
 135
 136 dual_timestamp* dual_timestamp_from_monotonic(dual_timestamp *ts, usec_t u) {
 137         int64_t delta;
 138         assert(ts);
 139
 140         if (u == USEC_INFINITY) {
 141                 ts->realtime = ts->monotonic = USEC_INFINITY;
 142                 return ts;
 143         }
 144
 145         ts->monotonic = u;
 146         delta = (int64_t) now(CLOCK_MONOTONIC) - (int64_t) u;
 147         ts->realtime = usec_sub_signed(now(CLOCK_REALTIME), delta);
 148
 149         return ts;
 150 }
 151
 152 dual_timestamp* dual_timestamp_from_boottime_or_monotonic(dual_timestamp *ts, usec_t u) {
 153         int64_t delta;
 154
 155         if (u == USEC_INFINITY) {
 156                 ts->realtime = ts->monotonic = USEC_INFINITY;
 157                 return ts;
 158         }
 159
 160         dual_timestamp_get(ts);
 161         delta = (int64_t) now(clock_boottime_or_monotonic()) - (int64_t) u;
 162         ts->realtime = usec_sub_signed(ts->realtime, delta);
 163         ts->monotonic = usec_sub_signed(ts->monotonic, delta);
 164
 165         return ts;
 166 }
 167 #endif // 0
 168
 169 usec_t triple_timestamp_by_clock(triple_timestamp *ts, clockid_t clock) {
 170
 171         switch (clock) {
 172
 173         case CLOCK_REALTIME:
 174         case CLOCK_REALTIME_ALARM:
 175                 return ts->realtime;
 176
 177         case CLOCK_MONOTONIC:
 178                 return ts->monotonic;
 179
 180         case CLOCK_BOOTTIME:
 181         case CLOCK_BOOTTIME_ALARM:
 182                 return ts->boottime;
 183
 184         default:
 185                 return USEC_INFINITY;
 186         }
 187 }
 188
 189 usec_t timespec_load(const struct timespec *ts) {
 190         assert(ts);
 191
 192         if (ts->tv_sec < 0 || ts->tv_nsec < 0)
 193                 return USEC_INFINITY;
 194
 195         if ((usec_t) ts->tv_sec > (UINT64_MAX - (ts->tv_nsec / NSEC_PER_USEC)) / USEC_PER_SEC)
 196                 return USEC_INFINITY;
 197
 198         return
 199                 (usec_t) ts->tv_sec * USEC_PER_SEC +
 200                 (usec_t) ts->tv_nsec / NSEC_PER_USEC;
 201 }
 202
 203 #if 0 /// UNNEEDED by elogind
 204 nsec_t timespec_load_nsec(const struct timespec *ts) {
 205         assert(ts);
 206
 207         if (ts->tv_sec < 0 || ts->tv_nsec < 0)
 208                 return NSEC_INFINITY;
 209
 210         if ((nsec_t) ts->tv_sec >= (UINT64_MAX - ts->tv_nsec) / NSEC_PER_SEC)
 211                 return NSEC_INFINITY;
 212
 213         return (nsec_t) ts->tv_sec * NSEC_PER_SEC + (nsec_t) ts->tv_nsec;
 214 }
 215 #endif // 0
 216
 217 struct timespec *timespec_store(struct timespec *ts, usec_t u)  {
 218         assert(ts);
 219
 220         if (u == USEC_INFINITY ||
 221             u / USEC_PER_SEC >= TIME_T_MAX) {
 222                 ts->tv_sec = (time_t) -1;
 223                 ts->tv_nsec = (long) -1;
 224                 return ts;
 225         }
 226
 227         ts->tv_sec = (time_t) (u / USEC_PER_SEC);
 228         ts->tv_nsec = (long int) ((u % USEC_PER_SEC) * NSEC_PER_USEC);
 229
 230         return ts;
 231 }
 232
 233 usec_t timeval_load(const struct timeval *tv) {
 234         assert(tv);
 235
 236         if (tv->tv_sec < 0 || tv->tv_usec < 0)
 237                 return USEC_INFINITY;
 238
 239         if ((usec_t) tv->tv_sec > (UINT64_MAX - tv->tv_usec) / USEC_PER_SEC)
 240                 return USEC_INFINITY;
 241
 242         return
 243                 (usec_t) tv->tv_sec * USEC_PER_SEC +
 244                 (usec_t) tv->tv_usec;
 245 }
 246
 247 struct timeval *timeval_store(struct timeval *tv, usec_t u) {
 248         assert(tv);
 249
 250         if (u == USEC_INFINITY ||
 251             u / USEC_PER_SEC > TIME_T_MAX) {
 252                 tv->tv_sec = (time_t) -1;
 253                 tv->tv_usec = (suseconds_t) -1;
 254         } else {
 255                 tv->tv_sec = (time_t) (u / USEC_PER_SEC);
 256                 tv->tv_usec = (suseconds_t) (u % USEC_PER_SEC);
 257         }
 258
 259         return tv;
 260 }
 261
 262 static char *format_timestamp_internal(
 263                 char *buf,
 264                 size_t l,
 265                 usec_t t,
 266                 bool utc,
 267                 bool us) {
 268
 269         /* The weekdays in non-localized (English) form. We use this instead of the localized form, so that our
 270          * generated timestamps may be parsed with parse_timestamp(), and always read the same. */
 271         static const char * const weekdays[] = {
 272                 [0] = "Sun",
 273                 [1] = "Mon",
 274                 [2] = "Tue",
 275                 [3] = "Wed",
 276                 [4] = "Thu",
 277                 [5] = "Fri",
 278                 [6] = "Sat",
 279         };
 280
 281         struct tm tm;
 282         time_t sec;
 283         size_t n;
 284
 285         assert(buf);
 286
 287         if (l <
 288             3 +                  /* week day */
 289             1 + 10 +             /* space and date */
 290             1 + 8 +              /* space and time */
 291             (us ? 1 + 6 : 0) +   /* "." and microsecond part */
 292             1 + 1 +              /* space and shortest possible zone */
 293             1)
 294                 return NULL; /* Not enough space even for the shortest form. */
 295         if (t <= 0 || t == USEC_INFINITY)
 296                 return NULL; /* Timestamp is unset */
 297
 298         /* Let's not format times with years > 9999 */
 299         if (t > USEC_TIMESTAMP_FORMATTABLE_MAX)
 300                 return NULL;
 301
 302         sec = (time_t) (t / USEC_PER_SEC); /* Round down */
 303
 304         if (!localtime_or_gmtime_r(&sec, &tm, utc))
 305                 return NULL;
 306
 307         /* Start with the week day */
 308         assert((size_t) tm.tm_wday < ELEMENTSOF(weekdays));
 309         memcpy(buf, weekdays[tm.tm_wday], 4);
 310
 311         /* Add the main components */
 312         if (strftime(buf + 3, l - 3, " %Y-%m-%d %H:%M:%S", &tm) <= 0)
 313                 return NULL; /* Doesn't fit */
 314
 315         /* Append the microseconds part, if that's requested */
 316         if (us) {
 317                 n = strlen(buf);
 318                 if (n + 8 > l)
 319                         return NULL; /* Microseconds part doesn't fit. */
 320
 321                 sprintf(buf + n, ".%06"PRI_USEC, t % USEC_PER_SEC);
 322         }
 323
 324         /* Append the timezone */
 325         n = strlen(buf);
 326         if (utc) {
 327                 /* If this is UTC then let's explicitly use the "UTC" string here, because gmtime_r() normally uses the
 328                  * obsolete "GMT" instead. */
 329                 if (n + 5 > l)
 330                         return NULL; /* "UTC" doesn't fit. */
 331
 332                 strcpy(buf + n, " UTC");
 333
 334         } else if (!isempty(tm.tm_zone)) {
 335                 size_t tn;
 336
 337                 /* An explicit timezone is specified, let's use it, if it fits */
 338                 tn = strlen(tm.tm_zone);
 339                 if (n + 1 + tn + 1 > l) {
 340                         /* The full time zone does not fit in. Yuck. */
 341
 342                         if (n + 1 + _POSIX_TZNAME_MAX + 1 > l)
 343                                 return NULL; /* Not even enough space for the POSIX minimum (of 6)? In that case, complain that it doesn't fit */
 344
 345                         /* So the time zone doesn't fit in fully, but the caller passed enough space for the POSIX
 346                          * minimum time zone length. In this case suppress the timezone entirely, in order not to dump
 347                          * an overly long, hard to read string on the user. This should be safe, because the user will
 348                          * assume the local timezone anyway if none is shown. And so does parse_timestamp(). */
 349                 } else {
 350                         buf[n++] = ' ';
 351                         strcpy(buf + n, tm.tm_zone);
 352                 }
 353         }
 354
 355         return buf;
 356 }
 357
 358 char *format_timestamp(char *buf, size_t l, usec_t t) {
 359         return format_timestamp_internal(buf, l, t, false, false);
 360 }
 361
 362 #if 0 /// UNNEEDED by elogind
 363 char *format_timestamp_utc(char *buf, size_t l, usec_t t) {
 364         return format_timestamp_internal(buf, l, t, true, false);
 365 }
 366 #endif // 0
 367
 368 char *format_timestamp_us(char *buf, size_t l, usec_t t) {
 369         return format_timestamp_internal(buf, l, t, false, true);
 370 }
 371
 372 #if 0 /// UNNEEDED by elogind
 373 char *format_timestamp_us_utc(char *buf, size_t l, usec_t t) {
 374         return format_timestamp_internal(buf, l, t, true, true);
 375 }
 376 #endif // 0
 377
 378 char *format_timestamp_relative(char *buf, size_t l, usec_t t) {
 379         const char *s;
 380         usec_t n, d;
 381
 382         if (t <= 0 || t == USEC_INFINITY)
 383                 return NULL;
 384
 385         n = now(CLOCK_REALTIME);
 386         if (n > t) {
 387                 d = n - t;
 388                 s = "ago";
 389         } else {
 390                 d = t - n;
 391                 s = "left";
 392         }
 393
 394         if (d >= USEC_PER_YEAR)
 395                 snprintf(buf, l, USEC_FMT " years " USEC_FMT " months %s",
 396                          d / USEC_PER_YEAR,
 397                          (d % USEC_PER_YEAR) / USEC_PER_MONTH, s);
 398         else if (d >= USEC_PER_MONTH)
 399                 snprintf(buf, l, USEC_FMT " months " USEC_FMT " days %s",
 400                          d / USEC_PER_MONTH,
 401                          (d % USEC_PER_MONTH) / USEC_PER_DAY, s);
 402         else if (d >= USEC_PER_WEEK)
 403                 snprintf(buf, l, USEC_FMT " weeks " USEC_FMT " days %s",
 404                          d / USEC_PER_WEEK,
 405                          (d % USEC_PER_WEEK) / USEC_PER_DAY, s);
 406         else if (d >= 2*USEC_PER_DAY)
 407                 snprintf(buf, l, USEC_FMT " days %s", d / USEC_PER_DAY, s);
 408         else if (d >= 25*USEC_PER_HOUR)
 409                 snprintf(buf, l, "1 day " USEC_FMT "h %s",
 410                          (d - USEC_PER_DAY) / USEC_PER_HOUR, s);
 411         else if (d >= 6*USEC_PER_HOUR)
 412                 snprintf(buf, l, USEC_FMT "h %s",
 413                          d / USEC_PER_HOUR, s);
 414         else if (d >= USEC_PER_HOUR)
 415                 snprintf(buf, l, USEC_FMT "h " USEC_FMT "min %s",
 416                          d / USEC_PER_HOUR,
 417                          (d % USEC_PER_HOUR) / USEC_PER_MINUTE, s);
 418         else if (d >= 5*USEC_PER_MINUTE)
 419                 snprintf(buf, l, USEC_FMT "min %s",
 420                          d / USEC_PER_MINUTE, s);
 421         else if (d >= USEC_PER_MINUTE)
 422                 snprintf(buf, l, USEC_FMT "min " USEC_FMT "s %s",
 423                          d / USEC_PER_MINUTE,
 424                          (d % USEC_PER_MINUTE) / USEC_PER_SEC, s);
 425         else if (d >= USEC_PER_SEC)
 426                 snprintf(buf, l, USEC_FMT "s %s",
 427                          d / USEC_PER_SEC, s);
 428         else if (d >= USEC_PER_MSEC)
 429                 snprintf(buf, l, USEC_FMT "ms %s",
 430                          d / USEC_PER_MSEC, s);
 431         else if (d > 0)
 432                 snprintf(buf, l, USEC_FMT"us %s",
 433                          d, s);
 434         else
 435                 snprintf(buf, l, "now");
 436
 437         buf[l-1] = 0;
 438         return buf;
 439 }
 440
 441 char *format_timespan(char *buf, size_t l, usec_t t, usec_t accuracy) {
 442         static const struct {
 443                 const char *suffix;
 444                 usec_t usec;
 445         } table[] = {
 446                 { "y",     USEC_PER_YEAR   },
 447                 { "month", USEC_PER_MONTH  },
 448                 { "w",     USEC_PER_WEEK   },
 449                 { "d",     USEC_PER_DAY    },
 450                 { "h",     USEC_PER_HOUR   },
 451                 { "min",   USEC_PER_MINUTE },
 452                 { "s",     USEC_PER_SEC    },
 453                 { "ms",    USEC_PER_MSEC   },
 454                 { "us",    1               },
 455         };
 456
 457         unsigned i;
 458         char *p = buf;
 459         bool something = false;
 460
 461         assert(buf);
 462         assert(l > 0);
 463
 464         if (t == USEC_INFINITY) {
 465                 strncpy(p, "infinity", l-1);
 466                 p[l-1] = 0;
 467                 return p;
 468         }
 469
 470         if (t <= 0) {
 471                 strncpy(p, "0", l-1);
 472                 p[l-1] = 0;
 473                 return p;
 474         }
 475
 476         /* The result of this function can be parsed with parse_sec */
 477
 478         for (i = 0; i < ELEMENTSOF(table); i++) {
 479                 int k = 0;
 480                 size_t n;
 481                 bool done = false;
 482                 usec_t a, b;
 483
 484                 if (t <= 0)
 485                         break;
 486
 487                 if (t < accuracy && something)
 488                         break;
 489
 490                 if (t < table[i].usec)
 491                         continue;
 492
 493                 if (l <= 1)
 494                         break;
 495
 496                 a = t / table[i].usec;
 497                 b = t % table[i].usec;
 498
 499                 /* Let's see if we should shows this in dot notation */
 500                 if (t < USEC_PER_MINUTE && b > 0) {
 501                         usec_t cc;
 502                         int j;
 503
 504                         j = 0;
 505                         for (cc = table[i].usec; cc > 1; cc /= 10)
 506                                 j++;
 507
 508                         for (cc = accuracy; cc > 1; cc /= 10) {
 509                                 b /= 10;
 510                                 j--;
 511                         }
 512
 513                         if (j > 0) {
 514                                 k = snprintf(p, l,
 515                                              "%s"USEC_FMT".%0*"PRI_USEC"%s",
 516                                              p > buf ? " " : "",
 517                                              a,
 518                                              j,
 519                                              b,
 520                                              table[i].suffix);
 521
 522                                 t = 0;
 523                                 done = true;
 524                         }
 525                 }
 526
 527                 /* No? Then let's show it normally */
 528                 if (!done) {
 529                         k = snprintf(p, l,
 530                                      "%s"USEC_FMT"%s",
 531                                      p > buf ? " " : "",
 532                                      a,
 533                                      table[i].suffix);
 534
 535                         t = b;
 536                 }
 537
 538                 n = MIN((size_t) k, l);
 539
 540                 l -= n;
 541                 p += n;
 542
 543                 something = true;
 544         }
 545
 546         *p = 0;
 547
 548         return buf;
 549 }
 550
 551 #if 0 /// UNNEEDED by elogind
 552 void dual_timestamp_serialize(FILE *f, const char *name, dual_timestamp *t) {
 553
 554         assert(f);
 555         assert(name);
 556         assert(t);
 557
 558         if (!dual_timestamp_is_set(t))
 559                 return;
 560
 561         fprintf(f, "%s="USEC_FMT" "USEC_FMT"\n",
 562                 name,
 563                 t->realtime,
 564                 t->monotonic);
 565 }
 566
 567 int dual_timestamp_deserialize(const char *value, dual_timestamp *t) {
 568         uint64_t a, b;
 569         int r, pos;
 570
 571         assert(value);
 572         assert(t);
 573
 574         pos = strspn(value, WHITESPACE);
 575         if (value[pos] == '-')
 576                 return -EINVAL;
 577         pos += strspn(value + pos, DIGITS);
 578         pos += strspn(value + pos, WHITESPACE);
 579         if (value[pos] == '-')
 580                 return -EINVAL;
 581
 582         r = sscanf(value, "%" PRIu64 "%" PRIu64 "%n", &a, &b, &pos);
 583         if (r != 2) {
 584                 log_debug("Failed to parse dual timestamp value \"%s\".", value);
 585                 return -EINVAL;
 586         }
 587
 588         if (value[pos] != '\0')
 589                 /* trailing garbage */
 590                 return -EINVAL;
 591
 592         t->realtime = a;
 593         t->monotonic = b;
 594
 595         return 0;
 596 }
 597
 598 #endif // 0
 599 int timestamp_deserialize(const char *value, usec_t *timestamp) {
 600         int r;
 601
 602         assert(value);
 603
 604         r = safe_atou64(value, timestamp);
 605         if (r < 0)
 606                 return log_debug_errno(r, "Failed to parse timestamp value \"%s\": %m", value);
 607
 608         return r;
 609 }
 610
 611 #if 0 /// UNNEEDED by elogind
 612 static int parse_timestamp_impl(const char *t, usec_t *usec, bool with_tz) {
 613         static const struct {
 614                 const char *name;
 615                 const int nr;
 616         } day_nr[] = {
 617                 { "Sunday",    0 },
 618                 { "Sun",       0 },
 619                 { "Monday",    1 },
 620                 { "Mon",       1 },
 621                 { "Tuesday",   2 },
 622                 { "Tue",       2 },
 623                 { "Wednesday", 3 },
 624                 { "Wed",       3 },
 625                 { "Thursday",  4 },
 626                 { "Thu",       4 },
 627                 { "Friday",    5 },
 628                 { "Fri",       5 },
 629                 { "Saturday",  6 },
 630                 { "Sat",       6 },
 631         };
 632
 633         const char *k, *utc = NULL, *tzn = NULL;
 634         struct tm tm, copy;
 635         time_t x;
 636         usec_t x_usec, plus = 0, minus = 0, ret;
 637         int r, weekday = -1, dst = -1;
 638         unsigned i;
 639
 640         /*
 641          * Allowed syntaxes:
 642          *
 643          *   2012-09-22 16:34:22
 644          *   2012-09-22 16:34     (seconds will be set to 0)
 645          *   2012-09-22           (time will be set to 00:00:00)
 646          *   16:34:22             (date will be set to today)
 647          *   16:34                (date will be set to today, seconds to 0)
 648          *   now
 649          *   yesterday            (time is set to 00:00:00)
 650          *   today                (time is set to 00:00:00)
 651          *   tomorrow             (time is set to 00:00:00)
 652          *   +5min
 653          *   -5days
 654          *   @2147483647          (seconds since epoch)
 655          *
 656          */
 657
 658         assert(t);
 659         assert(usec);
 660
 661         if (t[0] == '@' && !with_tz)
 662                 return parse_sec(t + 1, usec);
 663
 664         ret = now(CLOCK_REALTIME);
 665
 666         if (!with_tz) {
 667                 if (streq(t, "now"))
 668                         goto finish;
 669
 670                 else if (t[0] == '+') {
 671                         r = parse_sec(t+1, &plus);
 672                         if (r < 0)
 673                                 return r;
 674
 675                         goto finish;
 676
 677                 } else if (t[0] == '-') {
 678                         r = parse_sec(t+1, &minus);
 679                         if (r < 0)
 680                                 return r;
 681
 682                         goto finish;
 683
 684                 } else if ((k = endswith(t, " ago"))) {
 685                         t = strndupa(t, k - t);
 686
 687                         r = parse_sec(t, &minus);
 688                         if (r < 0)
 689                                 return r;
 690
 691                         goto finish;
 692
 693                 } else if ((k = endswith(t, " left"))) {
 694                         t = strndupa(t, k - t);
 695
 696                         r = parse_sec(t, &plus);
 697                         if (r < 0)
 698                                 return r;
 699
 700                         goto finish;
 701                 }
 702
 703                 /* See if the timestamp is suffixed with UTC */
 704                 utc = endswith_no_case(t, " UTC");
 705                 if (utc)
 706                         t = strndupa(t, utc - t);
 707                 else {
 708                         const char *e = NULL;
 709                         int j;
 710
 711                         tzset();
 712
 713                         /* See if the timestamp is suffixed by either the DST or non-DST local timezone. Note that we only
 714                         * support the local timezones here, nothing else. Not because we wouldn't want to, but simply because
 715                         * there are no nice APIs available to cover this. By accepting the local time zone strings, we make
 716                         * sure that all timestamps written by format_timestamp() can be parsed correctly, even though we don't
 717                         * support arbitrary timezone specifications.  */
 718
 719                         for (j = 0; j <= 1; j++) {
 720
 721                                 if (isempty(tzname[j]))
 722                                         continue;
 723
 724                                 e = endswith_no_case(t, tzname[j]);
 725                                 if (!e)
 726                                         continue;
 727                                 if (e == t)
 728                                         continue;
 729                                 if (e[-1] != ' ')
 730                                         continue;
 731
 732                                 break;
 733                         }
 734
 735                         if (IN_SET(j, 0, 1)) {
 736                                 /* Found one of the two timezones specified. */
 737                                 t = strndupa(t, e - t - 1);
 738                                 dst = j;
 739                                 tzn = tzname[j];
 740                         }
 741                 }
 742         }
 743
 744         x = (time_t) (ret / USEC_PER_SEC);
 745         x_usec = 0;
 746
 747         if (!localtime_or_gmtime_r(&x, &tm, utc))
 748                 return -EINVAL;
 749
 750         tm.tm_isdst = dst;
 751         if (!with_tz && tzn)
 752                 tm.tm_zone = tzn;
 753
 754         if (streq(t, "today")) {
 755                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
 756                 goto from_tm;
 757
 758         } else if (streq(t, "yesterday")) {
 759                 tm.tm_mday--;
 760                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
 761                 goto from_tm;
 762
 763         } else if (streq(t, "tomorrow")) {
 764                 tm.tm_mday++;
 765                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
 766                 goto from_tm;
 767         }
 768
 769         for (i = 0; i < ELEMENTSOF(day_nr); i++) {
 770                 size_t skip;
 771
 772                 if (!startswith_no_case(t, day_nr[i].name))
 773                         continue;
 774
 775                 skip = strlen(day_nr[i].name);
 776                 if (t[skip] != ' ')
 777                         continue;
 778
 779                 weekday = day_nr[i].nr;
 780                 t += skip + 1;
 781                 break;
 782         }
 783
 784         copy = tm;
 785         k = strptime(t, "%y-%m-%d %H:%M:%S", &tm);
 786         if (k) {
 787                 if (*k == '.')
 788                         goto parse_usec;
 789                 else if (*k == 0)
 790                         goto from_tm;
 791         }
 792
 793         tm = copy;
 794         k = strptime(t, "%Y-%m-%d %H:%M:%S", &tm);
 795         if (k) {
 796                 if (*k == '.')
 797                         goto parse_usec;
 798                 else if (*k == 0)
 799                         goto from_tm;
 800         }
 801
 802         tm = copy;
 803         k = strptime(t, "%y-%m-%d %H:%M", &tm);
 804         if (k && *k == 0) {
 805                 tm.tm_sec = 0;
 806                 goto from_tm;
 807         }
 808
 809         tm = copy;
 810         k = strptime(t, "%Y-%m-%d %H:%M", &tm);
 811         if (k && *k == 0) {
 812                 tm.tm_sec = 0;
 813                 goto from_tm;
 814         }
 815
 816         tm = copy;
 817         k = strptime(t, "%y-%m-%d", &tm);
 818         if (k && *k == 0) {
 819                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
 820                 goto from_tm;
 821         }
 822
 823         tm = copy;
 824         k = strptime(t, "%Y-%m-%d", &tm);
 825         if (k && *k == 0) {
 826                 tm.tm_sec = tm.tm_min = tm.tm_hour = 0;
 827                 goto from_tm;
 828         }
 829
 830         tm = copy;
 831         k = strptime(t, "%H:%M:%S", &tm);
 832         if (k) {
 833                 if (*k == '.')
 834                         goto parse_usec;
 835                 else if (*k == 0)
 836                         goto from_tm;
 837         }
 838
 839         tm = copy;
 840         k = strptime(t, "%H:%M", &tm);
 841         if (k && *k == 0) {
 842                 tm.tm_sec = 0;
 843                 goto from_tm;
 844         }
 845
 846         return -EINVAL;
 847
 848 parse_usec:
 849         {
 850                 unsigned add;
 851
 852                 k++;
 853                 r = parse_fractional_part_u(&k, 6, &add);
 854                 if (r < 0)
 855                         return -EINVAL;
 856
 857                 if (*k)
 858                         return -EINVAL;
 859
 860                 x_usec = add;
 861         }
 862
 863 from_tm:
 864         if (weekday >= 0 && tm.tm_wday != weekday)
 865                 return -EINVAL;
 866
 867         x = mktime_or_timegm(&tm, utc);
 868         if (x < 0)
 869                 return -EINVAL;
 870
 871         ret = (usec_t) x * USEC_PER_SEC + x_usec;
 872         if (ret > USEC_TIMESTAMP_FORMATTABLE_MAX)
 873                 return -EINVAL;
 874
 875 finish:
 876         if (ret + plus < ret) /* overflow? */
 877                 return -EINVAL;
 878         ret += plus;
 879         if (ret > USEC_TIMESTAMP_FORMATTABLE_MAX)
 880                 return -EINVAL;
 881
 882         if (ret >= minus)
 883                 ret -= minus;
 884         else
 885                 return -EINVAL;
 886
 887         *usec = ret;
 888
 889         return 0;
 890 }
 891
 892 typedef struct ParseTimestampResult {
 893         usec_t usec;
 894         int return_value;
 895 } ParseTimestampResult;
 896
 897 int parse_timestamp(const char *t, usec_t *usec) {
 898         char *last_space, *tz = NULL;
 899         ParseTimestampResult *shared, tmp;
 900         int r;
 901         pid_t pid;
 902
 903         last_space = strrchr(t, ' ');
 904         if (last_space != NULL && timezone_is_valid(last_space + 1))
 905                 tz = last_space + 1;
 906
 907         if (tz == NULL || endswith_no_case(t, " UTC"))
 908                 return parse_timestamp_impl(t, usec, false);
 909
 910         shared = mmap(NULL, sizeof *shared, PROT_READ|PROT_WRITE, MAP_SHARED|MAP_ANONYMOUS, -1, 0);
 911         if (shared == MAP_FAILED)
 912                 return negative_errno();
 913
 914         pid = fork();
 915
 916         if (pid == -1) {
 917                 int fork_errno = errno;
 918                 (void) munmap(shared, sizeof *shared);
 919                 return -fork_errno;
 920         }
 921
 922         if (pid == 0) {
 923                 bool with_tz = true;
 924
 925                 if (setenv("TZ", tz, 1) != 0) {
 926                         shared->return_value = negative_errno();
 927                         _exit(EXIT_FAILURE);
 928                 }
 929
 930                 tzset();
 931
 932                 /* If there is a timezone that matches the tzname fields, leave the parsing to the implementation.
 933                  * Otherwise just cut it off */
 934                 with_tz = !STR_IN_SET(tz, tzname[0], tzname[1]);
 935
 936                 /*cut off the timezone if we dont need it*/
 937                 if (with_tz)
 938                         t = strndupa(t, last_space - t);
 939
 940                 shared->return_value = parse_timestamp_impl(t, &shared->usec, with_tz);
 941
 942                 _exit(EXIT_SUCCESS);
 943         }
 944
 945         r = wait_for_terminate(pid, NULL);
 946         if (r < 0) {
 947                 (void) munmap(shared, sizeof *shared);
 948                 return r;
 949         }
 950
 951         tmp = *shared;
 952         if (munmap(shared, sizeof *shared) != 0)
 953                 return negative_errno();
 954
 955         if (tmp.return_value == 0)
 956                 *usec = tmp.usec;
 957
 958         return tmp.return_value;
 959 }
 960 #endif // 0
 961
 962 static char* extract_multiplier(char *p, usec_t *multiplier) {
 963         static const struct {
 964                 const char *suffix;
 965                 usec_t usec;
 966         } table[] = {
 967                 { "seconds", USEC_PER_SEC    },
 968                 { "second",  USEC_PER_SEC    },
 969                 { "sec",     USEC_PER_SEC    },
 970                 { "s",       USEC_PER_SEC    },
 971                 { "minutes", USEC_PER_MINUTE },
 972                 { "minute",  USEC_PER_MINUTE },
 973                 { "min",     USEC_PER_MINUTE },
 974                 { "months",  USEC_PER_MONTH  },
 975                 { "month",   USEC_PER_MONTH  },
 976                 { "M",       USEC_PER_MONTH  },
 977                 { "msec",    USEC_PER_MSEC   },
 978                 { "ms",      USEC_PER_MSEC   },
 979                 { "m",       USEC_PER_MINUTE },
 980                 { "hours",   USEC_PER_HOUR   },
 981                 { "hour",    USEC_PER_HOUR   },
 982                 { "hr",      USEC_PER_HOUR   },
 983                 { "h",       USEC_PER_HOUR   },
 984                 { "days",    USEC_PER_DAY    },
 985                 { "day",     USEC_PER_DAY    },
 986                 { "d",       USEC_PER_DAY    },
 987                 { "weeks",   USEC_PER_WEEK   },
 988                 { "week",    USEC_PER_WEEK   },
 989                 { "w",       USEC_PER_WEEK   },
 990                 { "years",   USEC_PER_YEAR   },
 991                 { "year",    USEC_PER_YEAR   },
 992                 { "y",       USEC_PER_YEAR   },
 993                 { "usec",    1ULL            },
 994                 { "us",      1ULL            },
 995                 { "µs",      1ULL            },
 996         };
 997         unsigned i;
 998
 999         for (i = 0; i < ELEMENTSOF(table); i++) {
1000                 char *e;
1001
1002                 e = startswith(p, table[i].suffix);
1003                 if (e) {
1004                         *multiplier = table[i].usec;
1005                         return e;
1006                 }
1007         }
1008
1009         return p;
1010 }
1011
1012 int parse_time(const char *t, usec_t *usec, usec_t default_unit) {
1013         const char *p, *s;
1014         usec_t r = 0;
1015         bool something = false;
1016
1017         assert(t);
1018         assert(usec);
1019         assert(default_unit > 0);
1020
1021         p = t;
1022
1023         p += strspn(p, WHITESPACE);
1024         s = startswith(p, "infinity");
1025         if (s) {
1026                 s += strspn(s, WHITESPACE);
1027                 if (*s != 0)
1028                         return -EINVAL;
1029
1030                 *usec = USEC_INFINITY;
1031                 return 0;
1032         }
1033
1034         for (;;) {
1035                 long long l, z = 0;
1036                 char *e;
1037                 unsigned n = 0;
1038                 usec_t multiplier = default_unit, k;
1039
1040                 p += strspn(p, WHITESPACE);
1041
1042                 if (*p == 0) {
1043                         if (!something)
1044                                 return -EINVAL;
1045
1046                         break;
1047                 }
1048
1049                 errno = 0;
1050                 l = strtoll(p, &e, 10);
1051                 if (errno > 0)
1052                         return -errno;
1053                 if (l < 0)
1054                         return -ERANGE;
1055
1056                 if (*e == '.') {
1057                         char *b = e + 1;
1058
1059                         errno = 0;
1060                         z = strtoll(b, &e, 10);
1061                         if (errno > 0)
1062                                 return -errno;
1063
1064                         if (z < 0)
1065                                 return -ERANGE;
1066
1067                         if (e == b)
1068                                 return -EINVAL;
1069
1070                         n = e - b;
1071
1072                 } else if (e == p)
1073                         return -EINVAL;
1074
1075                 e += strspn(e, WHITESPACE);
1076                 p = extract_multiplier(e, &multiplier);
1077
1078                 something = true;
1079
1080                 k = (usec_t) z * multiplier;
1081
1082                 for (; n > 0; n--)
1083                         k /= 10;
1084
1085                 r += (usec_t) l * multiplier + k;
1086         }
1087
1088         *usec = r;
1089
1090         return 0;
1091 }
1092
1093 int parse_sec(const char *t, usec_t *usec) {
1094         return parse_time(t, usec, USEC_PER_SEC);
1095 }
1096
1097 #if 0 /// UNNEEDED by elogind
1098 int parse_sec_fix_0(const char *t, usec_t *usec) {
1099         t += strspn(t, WHITESPACE);
1100         if (streq(t, "0")) {
1101                 *usec = USEC_INFINITY;
1102                 return 0;
1103         }
1104
1105         return parse_sec(t, usec);
1106 }
1107
1108 int parse_nsec(const char *t, nsec_t *nsec) {
1109         static const struct {
1110                 const char *suffix;
1111                 nsec_t nsec;
1112         } table[] = {
1113                 { "seconds", NSEC_PER_SEC },
1114                 { "second", NSEC_PER_SEC },
1115                 { "sec", NSEC_PER_SEC },
1116                 { "s", NSEC_PER_SEC },
1117                 { "minutes", NSEC_PER_MINUTE },
1118                 { "minute", NSEC_PER_MINUTE },
1119                 { "min", NSEC_PER_MINUTE },
1120                 { "months", NSEC_PER_MONTH },
1121                 { "month", NSEC_PER_MONTH },
1122                 { "msec", NSEC_PER_MSEC },
1123                 { "ms", NSEC_PER_MSEC },
1124                 { "m", NSEC_PER_MINUTE },
1125                 { "hours", NSEC_PER_HOUR },
1126                 { "hour", NSEC_PER_HOUR },
1127                 { "hr", NSEC_PER_HOUR },
1128                 { "h", NSEC_PER_HOUR },
1129                 { "days", NSEC_PER_DAY },
1130                 { "day", NSEC_PER_DAY },
1131                 { "d", NSEC_PER_DAY },
1132                 { "weeks", NSEC_PER_WEEK },
1133                 { "week", NSEC_PER_WEEK },
1134                 { "w", NSEC_PER_WEEK },
1135                 { "years", NSEC_PER_YEAR },
1136                 { "year", NSEC_PER_YEAR },
1137                 { "y", NSEC_PER_YEAR },
1138                 { "usec", NSEC_PER_USEC },
1139                 { "us", NSEC_PER_USEC },
1140                 { "µs", NSEC_PER_USEC },
1141                 { "nsec", 1ULL },
1142                 { "ns", 1ULL },
1143                 { "", 1ULL }, /* default is nsec */
1144         };
1145
1146         const char *p, *s;
1147         nsec_t r = 0;
1148         bool something = false;
1149
1150         assert(t);
1151         assert(nsec);
1152
1153         p = t;
1154
1155         p += strspn(p, WHITESPACE);
1156         s = startswith(p, "infinity");
1157         if (s) {
1158                 s += strspn(s, WHITESPACE);
1159                 if (*s != 0)
1160                         return -EINVAL;
1161
1162                 *nsec = NSEC_INFINITY;
1163                 return 0;
1164         }
1165
1166         for (;;) {
1167                 long long l, z = 0;
1168                 char *e;
1169                 unsigned i, n = 0;
1170
1171                 p += strspn(p, WHITESPACE);
1172
1173                 if (*p == 0) {
1174                         if (!something)
1175                                 return -EINVAL;
1176
1177                         break;
1178                 }
1179
1180                 errno = 0;
1181                 l = strtoll(p, &e, 10);
1182
1183                 if (errno > 0)
1184                         return -errno;
1185
1186                 if (l < 0)
1187                         return -ERANGE;
1188
1189                 if (*e == '.') {
1190                         char *b = e + 1;
1191
1192                         errno = 0;
1193                         z = strtoll(b, &e, 10);
1194                         if (errno > 0)
1195                                 return -errno;
1196
1197                         if (z < 0)
1198                                 return -ERANGE;
1199
1200                         if (e == b)
1201                                 return -EINVAL;
1202
1203                         n = e - b;
1204
1205                 } else if (e == p)
1206                         return -EINVAL;
1207
1208                 e += strspn(e, WHITESPACE);
1209
1210                 for (i = 0; i < ELEMENTSOF(table); i++)
1211                         if (startswith(e, table[i].suffix)) {
1212                                 nsec_t k = (nsec_t) z * table[i].nsec;
1213
1214                                 for (; n > 0; n--)
1215                                         k /= 10;
1216
1217                                 r += (nsec_t) l * table[i].nsec + k;
1218                                 p = e + strlen(table[i].suffix);
1219
1220                                 something = true;
1221                                 break;
1222                         }
1223
1224                 if (i >= ELEMENTSOF(table))
1225                         return -EINVAL;
1226
1227         }
1228
1229         *nsec = r;
1230
1231         return 0;
1232 }
1233
1234 bool ntp_synced(void) {
1235         struct timex txc = {};
1236
1237         if (adjtimex(&txc) < 0)
1238                 return false;
1239
1240         if (txc.status & STA_UNSYNC)
1241                 return false;
1242
1243         return true;
1244 }
1245
1246 int get_timezones(char ***ret) {
1247         _cleanup_fclose_ FILE *f = NULL;
1248         _cleanup_strv_free_ char **zones = NULL;
1249         size_t n_zones = 0, n_allocated = 0;
1250
1251         assert(ret);
1252
1253         zones = strv_new("UTC", NULL);
1254         if (!zones)
1255                 return -ENOMEM;
1256
1257         n_allocated = 2;
1258         n_zones = 1;
1259
1260         f = fopen("/usr/share/zoneinfo/zone.tab", "re");
1261         if (f) {
1262                 char l[LINE_MAX];
1263
1264                 FOREACH_LINE(l, f, return -errno) {
1265                         char *p, *w;
1266                         size_t k;
1267
1268                         p = strstrip(l);
1269
1270                         if (isempty(p) || *p == '#')
1271                                 continue;
1272
1273                         /* Skip over country code */
1274                         p += strcspn(p, WHITESPACE);
1275                         p += strspn(p, WHITESPACE);
1276
1277                         /* Skip over coordinates */
1278                         p += strcspn(p, WHITESPACE);
1279                         p += strspn(p, WHITESPACE);
1280
1281                         /* Found timezone name */
1282                         k = strcspn(p, WHITESPACE);
1283                         if (k <= 0)
1284                                 continue;
1285
1286                         w = strndup(p, k);
1287                         if (!w)
1288                                 return -ENOMEM;
1289
1290                         if (!GREEDY_REALLOC(zones, n_allocated, n_zones + 2)) {
1291                                 free(w);
1292                                 return -ENOMEM;
1293                         }
1294
1295                         zones[n_zones++] = w;
1296                         zones[n_zones] = NULL;
1297                 }
1298
1299                 strv_sort(zones);
1300
1301         } else if (errno != ENOENT)
1302                 return -errno;
1303
1304         *ret = zones;
1305         zones = NULL;
1306
1307         return 0;
1308 }
1309
1310 bool timezone_is_valid(const char *name) {
1311         bool slash = false;
1312         const char *p, *t;
1313         struct stat st;
1314
1315         if (isempty(name))
1316                 return false;
1317
1318         if (name[0] == '/')
1319                 return false;
1320
1321         for (p = name; *p; p++) {
1322                 if (!(*p >= '0' && *p <= '9') &&
1323                     !(*p >= 'a' && *p <= 'z') &&
1324                     !(*p >= 'A' && *p <= 'Z') &&
1325                     !(*p == '-' || *p == '_' || *p == '+' || *p == '/'))
1326                         return false;
1327
1328                 if (*p == '/') {
1329
1330                         if (slash)
1331                                 return false;
1332
1333                         slash = true;
1334                 } else
1335                         slash = false;
1336         }
1337
1338         if (slash)
1339                 return false;
1340
1341         t = strjoina("/usr/share/zoneinfo/", name);
1342         if (stat(t, &st) < 0)
1343                 return false;
1344
1345         if (!S_ISREG(st.st_mode))
1346                 return false;
1347
1348         return true;
1349 }
1350
1351 #endif // 0
1352 bool clock_boottime_supported(void) {
1353         static int supported = -1;
1354
1355         /* Note that this checks whether CLOCK_BOOTTIME is available in general as well as available for timerfds()! */
1356
1357         if (supported < 0) {
1358                 int fd;
1359
1360                 fd = timerfd_create(CLOCK_BOOTTIME, TFD_NONBLOCK|TFD_CLOEXEC);
1361                 if (fd < 0)
1362                         supported = false;
1363                 else {
1364                         safe_close(fd);
1365                         supported = true;
1366                 }
1367         }
1368
1369         return supported;
1370 }
1371
1372 #if 0 /// UNNEEDED by elogind
1373 clockid_t clock_boottime_or_monotonic(void) {
1374         if (clock_boottime_supported())
1375                 return CLOCK_BOOTTIME;
1376         else
1377                 return CLOCK_MONOTONIC;
1378 }
1379 #endif // 0
1380
1381 bool clock_supported(clockid_t clock) {
1382         struct timespec ts;
1383
1384         switch (clock) {
1385
1386         case CLOCK_MONOTONIC:
1387         case CLOCK_REALTIME:
1388                 return true;
1389
1390         case CLOCK_BOOTTIME:
1391                 return clock_boottime_supported();
1392
1393         case CLOCK_BOOTTIME_ALARM:
1394                 if (!clock_boottime_supported())
1395                         return false;
1396
1397                 /* fall through */
1398
1399         default:
1400                 /* For everything else, check properly */
1401                 return clock_gettime(clock, &ts) >= 0;
1402         }
1403 }
1404
1405 #if 0 /// UNNEEDED by elogind
1406 int get_timezone(char **tz) {
1407         _cleanup_free_ char *t = NULL;
1408         const char *e;
1409         char *z;
1410         int r;
1411
1412         r = readlink_malloc("/etc/localtime", &t);
1413         if (r < 0)
1414                 return r; /* returns EINVAL if not a symlink */
1415
1416         e = path_startswith(t, "/usr/share/zoneinfo/");
1417         if (!e)
1418                 e = path_startswith(t, "../usr/share/zoneinfo/");
1419         if (!e)
1420                 return -EINVAL;
1421
1422         if (!timezone_is_valid(e))
1423                 return -EINVAL;
1424
1425         z = strdup(e);
1426         if (!z)
1427                 return -ENOMEM;
1428
1429         *tz = z;
1430         return 0;
1431 }
1432
1433 time_t mktime_or_timegm(struct tm *tm, bool utc) {
1434         return utc ? timegm(tm) : mktime(tm);
1435 }
1436 #endif // 0
1437
1438 struct tm *localtime_or_gmtime_r(const time_t *t, struct tm *tm, bool utc) {
1439         return utc ? gmtime_r(t, tm) : localtime_r(t, tm);
1440 }
1441
1442 #if 0 /// UNNEEDED by elogind
1443 unsigned long usec_to_jiffies(usec_t u) {
1444         static thread_local unsigned long hz = 0;
1445         long r;
1446
1447         if (hz == 0) {
1448                 r = sysconf(_SC_CLK_TCK);
1449
1450                 assert(r > 0);
1451                 hz = r;
1452         }
1453
1454         return DIV_ROUND_UP(u , USEC_PER_SEC / hz);
1455 }
1456
1457 usec_t usec_shift_clock(usec_t x, clockid_t from, clockid_t to) {
1458         usec_t a, b;
1459
1460         if (x == USEC_INFINITY)
1461                 return USEC_INFINITY;
1462         if (map_clock_id(from) == map_clock_id(to))
1463                 return x;
1464
1465         a = now(from);
1466         b = now(to);
1467
1468         if (x > a)
1469                 /* x lies in the future */
1470                 return usec_add(b, usec_sub_unsigned(x, a));
1471         else
1472                 /* x lies in the past */
1473                 return usec_sub_unsigned(b, usec_sub_unsigned(a, x));
1474 }
1475 #endif // 0