src/timedate/timedated.c

   1 /* SPDX-License-Identifier: LGPL-2.1-or-later */
   2
   3 #include <errno.h>
   4 #include <sys/stat.h>
   5 #include <sys/timex.h>
   6 #include <sys/types.h>
   7 #include <unistd.h>
   8
   9 #include "sd-bus.h"
  10 #include "sd-event.h"
  11 #include "sd-messages.h"
  12
  13 #include "alloc-util.h"
  14 #include "bus-common-errors.h"
  15 #include "bus-error.h"
  16 #include "bus-get-properties.h"
  17 #include "bus-locator.h"
  18 #include "bus-log-control-api.h"
  19 #include "bus-map-properties.h"
  20 #include "bus-polkit.h"
  21 #include "bus-unit-util.h"
  22 #include "clock-util.h"
  23 #include "conf-files.h"
  24 #include "constants.h"
  25 #include "fd-util.h"
  26 #include "fileio-label.h"
  27 #include "fileio.h"
  28 #include "fs-util.h"
  29 #include "hashmap.h"
  30 #include "list.h"
  31 #include "main-func.h"
  32 #include "memory-util.h"
  33 #include "missing_capability.h"
  34 #include "path-util.h"
  35 #include "selinux-util.h"
  36 #include "service-util.h"
  37 #include "signal-util.h"
  38 #include "string-util.h"
  39 #include "strv.h"
  40 #include "unit-def.h"
  41 #include "unit-name.h"
  42 #include "user-util.h"
  43
  44 #define NULL_ADJTIME_UTC "0.0 0 0\n0\nUTC\n"
  45 #define NULL_ADJTIME_LOCAL "0.0 0 0\n0\nLOCAL\n"
  46
  47 #define UNIT_LIST_DIRS (const char* const*) CONF_PATHS_STRV("systemd/ntp-units.d")
  48
  49 typedef struct UnitStatusInfo {
  50         char *name;
  51         char *load_state;
  52         char *unit_file_state;
  53         char *active_state;
  54         char *path;
  55
  56         LIST_FIELDS(struct UnitStatusInfo, units);
  57 } UnitStatusInfo;
  58
  59 typedef struct Context {
  60         char *zone;
  61         bool local_rtc;
  62         Hashmap *polkit_registry;
  63         sd_bus_message *cache;
  64
  65         sd_bus_slot *slot_job_removed;
  66
  67         LIST_HEAD(UnitStatusInfo, units);
  68 } Context;
  69
  70 #define log_unit_full_errno_zerook(unit, level, error, ...)             \
  71         ({                                                              \
  72                 const UnitStatusInfo *_u = (unit);                      \
  73                 _u ? log_object_internal(level, error, PROJECT_FILE, __LINE__, __func__, "UNIT=", _u->name, NULL, NULL, ##__VA_ARGS__) : \
  74                         log_internal(level, error, PROJECT_FILE, __LINE__, __func__, ##__VA_ARGS__); \
  75         })
  76
  77 #define log_unit_full_errno(unit, level, error, ...) \
  78         ({                                                              \
  79                 int _error = (error);                                   \
  80                 ASSERT_NON_ZERO(_error);                                \
  81                 log_unit_full_errno_zerook(unit, level, _error, ##__VA_ARGS__); \
  82         })
  83
  84 #define log_unit_full(unit, level, ...) (void) log_unit_full_errno_zerook(unit, level, 0, ##__VA_ARGS__)
  85
  86 #define log_unit_debug(unit, ...)   log_unit_full(unit, LOG_DEBUG, ##__VA_ARGS__)
  87 #define log_unit_info(unit, ...)    log_unit_full(unit, LOG_INFO, ##__VA_ARGS__)
  88 #define log_unit_notice(unit, ...)  log_unit_full(unit, LOG_NOTICE, ##__VA_ARGS__)
  89 #define log_unit_warning(unit, ...) log_unit_full(unit, LOG_WARNING, ##__VA_ARGS__)
  90 #define log_unit_error(unit, ...)   log_unit_full(unit, LOG_ERR, ##__VA_ARGS__)
  91
  92 #define log_unit_debug_errno(unit, error, ...)   log_unit_full_errno(unit, LOG_DEBUG, error, ##__VA_ARGS__)
  93 #define log_unit_info_errno(unit, error, ...)    log_unit_full_errno(unit, LOG_INFO, error, ##__VA_ARGS__)
  94 #define log_unit_notice_errno(unit, error, ...)  log_unit_full_errno(unit, LOG_NOTICE, error, ##__VA_ARGS__)
  95 #define log_unit_warning_errno(unit, error, ...) log_unit_full_errno(unit, LOG_WARNING, error, ##__VA_ARGS__)
  96 #define log_unit_error_errno(unit, error, ...)   log_unit_full_errno(unit, LOG_ERR, error, ##__VA_ARGS__)
  97
  98 static void unit_status_info_clear(UnitStatusInfo *p) {
  99         assert(p);
 100
 101         p->load_state = mfree(p->load_state);
 102         p->unit_file_state = mfree(p->unit_file_state);
 103         p->active_state = mfree(p->active_state);
 104 }
 105
 106 static UnitStatusInfo *unit_status_info_free(UnitStatusInfo *p) {
 107         if (!p)
 108                 return NULL;
 109
 110         unit_status_info_clear(p);
 111         free(p->name);
 112         free(p->path);
 113         return mfree(p);
 114 }
 115
 116 DEFINE_TRIVIAL_CLEANUP_FUNC(UnitStatusInfo*, unit_status_info_free);
 117
 118 static void context_clear(Context *c) {
 119         assert(c);
 120
 121         free(c->zone);
 122         bus_verify_polkit_async_registry_free(c->polkit_registry);
 123         sd_bus_message_unref(c->cache);
 124
 125         sd_bus_slot_unref(c->slot_job_removed);
 126
 127         LIST_CLEAR(units, c->units, unit_status_info_free);
 128 }
 129
 130 static int context_add_ntp_service(Context *c, const char *s, const char *source) {
 131         _cleanup_(unit_status_info_freep) UnitStatusInfo *unit = NULL;
 132
 133         assert(c);
 134         assert(s);
 135         assert(source);
 136
 137         if (!unit_name_is_valid(s, UNIT_NAME_PLAIN))
 138                 return -EINVAL;
 139
 140         /* Do not add this if it is already listed */
 141         LIST_FOREACH(units, u, c->units)
 142                 if (streq(u->name, s))
 143                         return 0;
 144
 145         unit = new0(UnitStatusInfo, 1);
 146         if (!unit)
 147                 return -ENOMEM;
 148
 149         unit->name = strdup(s);
 150         if (!unit->name)
 151                 return -ENOMEM;
 152
 153         LIST_APPEND(units, c->units, unit);
 154         log_unit_debug(unit, "added from %s.", source);
 155         TAKE_PTR(unit);
 156
 157         return 0;
 158 }
 159
 160 static int context_parse_ntp_services_from_environment(Context *c) {
 161         const char *env, *p;
 162         int r;
 163
 164         assert(c);
 165
 166         env = getenv("SYSTEMD_TIMEDATED_NTP_SERVICES");
 167         if (!env)
 168                 return 0;
 169
 170         log_debug("Using list of ntp services from environment variable $SYSTEMD_TIMEDATED_NTP_SERVICES=%s.", env);
 171
 172         for (p = env;;) {
 173                 _cleanup_free_ char *word = NULL;
 174
 175                 r = extract_first_word(&p, &word, ":", 0);
 176                 if (r == 0)
 177                         break;
 178                 if (r == -ENOMEM)
 179                         return log_oom();
 180                 if (r < 0) {
 181                         log_error("Invalid syntax, ignoring: %s", env);
 182                         break;
 183                 }
 184
 185                 r = context_add_ntp_service(c, word, "$SYSTEMD_TIMEDATED_NTP_SERVICES");
 186                 if (r < 0)
 187                         log_warning_errno(r, "Failed to add NTP service \"%s\", ignoring: %m", word);
 188         }
 189
 190         return 1;
 191 }
 192
 193 static int context_parse_ntp_services_from_disk(Context *c) {
 194         _cleanup_strv_free_ char **files = NULL;
 195         int r;
 196
 197         r = conf_files_list_strv(&files, ".list", NULL, CONF_FILES_FILTER_MASKED, UNIT_LIST_DIRS);
 198         if (r < 0)
 199                 return log_error_errno(r, "Failed to enumerate .list files: %m");
 200
 201         STRV_FOREACH(f, files) {
 202                 _cleanup_fclose_ FILE *file = NULL;
 203
 204                 log_debug("Reading file '%s'", *f);
 205
 206                 r = fopen_unlocked(*f, "re", &file);
 207                 if (r < 0) {
 208                         log_error_errno(r, "Failed to open %s, ignoring: %m", *f);
 209                         continue;
 210                 }
 211
 212                 for (;;) {
 213                         _cleanup_free_ char *line = NULL;
 214
 215                         r = read_stripped_line(file, LINE_MAX, &line);
 216                         if (r < 0) {
 217                                 log_error_errno(r, "Failed to read %s, ignoring: %m", *f);
 218                                 continue;
 219                         }
 220                         if (r == 0)
 221                                 break;
 222
 223                         if (isempty(line) || startswith(line, "#"))
 224                                 continue;
 225
 226                         r = context_add_ntp_service(c, line, *f);
 227                         if (r < 0)
 228                                 log_warning_errno(r, "Failed to add NTP service \"%s\", ignoring: %m", line);
 229                 }
 230         }
 231
 232         return 1;
 233 }
 234
 235 static int context_parse_ntp_services(Context *c) {
 236         int r;
 237
 238         r = context_parse_ntp_services_from_environment(c);
 239         if (r != 0)
 240                 return r;
 241
 242         return context_parse_ntp_services_from_disk(c);
 243 }
 244
 245 static int context_ntp_service_is_active(Context *c) {
 246         int count = 0;
 247
 248         assert(c);
 249
 250         /* Call context_update_ntp_status() to update UnitStatusInfo before calling this. */
 251
 252         LIST_FOREACH(units, info, c->units)
 253                 count += !STRPTR_IN_SET(info->active_state, "inactive", "failed");
 254
 255         return count;
 256 }
 257
 258 static int context_ntp_service_exists(Context *c) {
 259         int count = 0;
 260
 261         assert(c);
 262
 263         /* Call context_update_ntp_status() to update UnitStatusInfo before calling this. */
 264
 265         LIST_FOREACH(units, info, c->units)
 266                 count += streq_ptr(info->load_state, "loaded");
 267
 268         return count;
 269 }
 270
 271 static int context_read_data(Context *c) {
 272         _cleanup_free_ char *t = NULL;
 273         int r;
 274
 275         assert(c);
 276
 277         r = get_timezone(&t);
 278         if (r == -EINVAL)
 279                 log_warning_errno(r, "/etc/localtime should be a symbolic link to a time zone data file in /usr/share/zoneinfo/.");
 280         else if (r < 0)
 281                 log_warning_errno(r, "Failed to get target of /etc/localtime: %m");
 282
 283         free_and_replace(c->zone, t);
 284
 285         c->local_rtc = clock_is_localtime(NULL) > 0;
 286
 287         return 0;
 288 }
 289
 290 static int context_write_data_timezone(Context *c) {
 291         _cleanup_free_ char *p = NULL;
 292         const char *source;
 293
 294         assert(c);
 295
 296         /* No timezone is very similar to UTC. Hence in either of these cases link the UTC file in. Except if
 297          * it isn't installed, in which case we remove the symlink altogether. Since glibc defaults to an
 298          * internal version of UTC in that case behaviour is mostly equivalent. We still prefer creating the
 299          * symlink though, since things are more self explanatory then. */
 300
 301         if (isempty(c->zone) || streq(c->zone, "UTC")) {
 302
 303                 if (access("/usr/share/zoneinfo/UTC", F_OK) < 0) {
 304
 305                         if (unlink("/etc/localtime") < 0 && errno != ENOENT)
 306                                 return -errno;
 307
 308                         return 0;
 309                 }
 310
 311                 source = "../usr/share/zoneinfo/UTC";
 312         } else {
 313                 p = path_join("../usr/share/zoneinfo", c->zone);
 314                 if (!p)
 315                         return -ENOMEM;
 316
 317                 source = p;
 318         }
 319
 320         return symlink_atomic(source, "/etc/localtime");
 321 }
 322
 323 static int context_write_data_local_rtc(Context *c) {
 324         _cleanup_free_ char *s = NULL, *w = NULL;
 325         int r;
 326
 327         assert(c);
 328
 329         r = read_full_file("/etc/adjtime", &s, NULL);
 330         if (r < 0) {
 331                 if (r != -ENOENT)
 332                         return r;
 333
 334                 if (!c->local_rtc)
 335                         return 0;
 336
 337                 w = strdup(NULL_ADJTIME_LOCAL);
 338                 if (!w)
 339                         return -ENOMEM;
 340         } else {
 341                 char *p;
 342                 const char *e = "\n"; /* default if there is less than 3 lines */
 343                 const char *prepend = "";
 344                 size_t a, b;
 345
 346                 p = strchrnul(s, '\n');
 347                 if (*p == '\0')
 348                         /* only one line, no \n terminator */
 349                         prepend = "\n0\n";
 350                 else if (p[1] == '\0') {
 351                         /* only one line, with \n terminator */
 352                         ++p;
 353                         prepend = "0\n";
 354                 } else {
 355                         p = strchr(p+1, '\n');
 356                         if (!p) {
 357                                 /* only two lines, no \n terminator */
 358                                 prepend = "\n";
 359                                 p = s + strlen(s);
 360                         } else {
 361                                 char *end;
 362                                 /* third line might have a \n terminator or not */
 363                                 p++;
 364                                 end = strchr(p, '\n');
 365                                 /* if we actually have a fourth line, use that as suffix "e", otherwise the default \n */
 366                                 if (end)
 367                                         e = end;
 368                         }
 369                 }
 370
 371                 a = p - s;
 372                 b = strlen(e);
 373
 374                 w = new(char, a + (c->local_rtc ? 5 : 3) + strlen(prepend) + b + 1);
 375                 if (!w)
 376                         return -ENOMEM;
 377
 378                 *(char*) mempcpy(stpcpy(stpcpy(mempcpy(w, s, a), prepend), c->local_rtc ? "LOCAL" : "UTC"), e, b) = 0;
 379
 380                 if (streq(w, NULL_ADJTIME_UTC)) {
 381                         if (unlink("/etc/adjtime") < 0)
 382                                 if (errno != ENOENT)
 383                                         return -errno;
 384
 385                         return 0;
 386                 }
 387         }
 388
 389         r = mac_init();
 390         if (r < 0)
 391                 return r;
 392
 393         return write_string_file_atomic_label("/etc/adjtime", w);
 394 }
 395
 396 static int context_update_ntp_status(Context *c, sd_bus *bus, sd_bus_message *m) {
 397         static const struct bus_properties_map map[] = {
 398                 { "LoadState",     "s", NULL, offsetof(UnitStatusInfo, load_state)      },
 399                 { "ActiveState",   "s", NULL, offsetof(UnitStatusInfo, active_state)    },
 400                 { "UnitFileState", "s", NULL, offsetof(UnitStatusInfo, unit_file_state) },
 401                 {}
 402         };
 403         int r;
 404
 405         assert(c);
 406         assert(bus);
 407
 408         /* Suppress calling context_update_ntp_status() multiple times within single DBus transaction. */
 409         if (m) {
 410                 if (m == c->cache)
 411                         return 0;
 412
 413                 sd_bus_message_unref(c->cache);
 414                 c->cache = sd_bus_message_ref(m);
 415         }
 416
 417         LIST_FOREACH(units, u, c->units) {
 418                 _cleanup_(sd_bus_error_free) sd_bus_error error = SD_BUS_ERROR_NULL;
 419                 _cleanup_free_ char *path = NULL;
 420
 421                 unit_status_info_clear(u);
 422
 423                 path = unit_dbus_path_from_name(u->name);
 424                 if (!path)
 425                         return -ENOMEM;
 426
 427                 r = bus_map_all_properties(
 428                                 bus,
 429                                 "org.freedesktop.systemd1",
 430                                 path,
 431                                 map,
 432                                 BUS_MAP_STRDUP,
 433                                 &error,
 434                                 NULL,
 435                                 u);
 436                 if (r < 0)
 437                         return log_unit_error_errno(u, r, "Failed to get properties: %s", bus_error_message(&error, r));
 438         }
 439
 440         return 0;
 441 }
 442
 443 static int match_job_removed(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 444         Context *c = ASSERT_PTR(userdata);
 445         const char *path;
 446         unsigned n = 0;
 447         int r;
 448
 449         assert(m);
 450
 451         r = sd_bus_message_read(m, "uoss", NULL, &path, NULL, NULL);
 452         if (r < 0) {
 453                 bus_log_parse_error(r);
 454                 return 0;
 455         }
 456
 457         LIST_FOREACH(units, u, c->units)
 458                 if (streq_ptr(path, u->path))
 459                         u->path = mfree(u->path);
 460                 else
 461                         n += !!u->path;
 462
 463         if (n == 0) {
 464                 c->slot_job_removed = sd_bus_slot_unref(c->slot_job_removed);
 465
 466                 (void) sd_bus_emit_properties_changed(sd_bus_message_get_bus(m),
 467                                                       "/org/freedesktop/timedate1", "org.freedesktop.timedate1", "NTP",
 468                                                       NULL);
 469         }
 470
 471         return 0;
 472 }
 473
 474 static int unit_start_or_stop(UnitStatusInfo *u, sd_bus *bus, sd_bus_error *error, bool start) {
 475         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
 476         const char *path;
 477         int r;
 478
 479         assert(u);
 480         assert(bus);
 481         assert(error);
 482
 483         r = bus_call_method(
 484                 bus,
 485                 bus_systemd_mgr,
 486                 start ? "StartUnit" : "StopUnit",
 487                 error,
 488                 &reply,
 489                 "ss",
 490                 u->name,
 491                 "replace");
 492         log_unit_full_errno_zerook(u, r < 0 ? LOG_WARNING : LOG_DEBUG, r,
 493                                    "%s unit: %m", start ? "Starting" : "Stopping");
 494         if (r < 0)
 495                 return r;
 496
 497         r = sd_bus_message_read(reply, "o", &path);
 498         if (r < 0)
 499                 return bus_log_parse_error(r);
 500
 501         r = free_and_strdup(&u->path, path);
 502         if (r < 0)
 503                 return log_oom();
 504
 505         return 0;
 506 }
 507
 508 static int unit_enable_or_disable(UnitStatusInfo *u, sd_bus *bus, sd_bus_error *error, bool enable) {
 509         int r;
 510
 511         assert(u);
 512         assert(bus);
 513         assert(error);
 514
 515         /* Call context_update_ntp_status() to update UnitStatusInfo before calling this. */
 516
 517         if (streq(u->unit_file_state, "enabled") == enable) {
 518                 log_unit_debug(u, "already %sd.", enable_disable(enable));
 519                 return 0;
 520         }
 521
 522         log_unit_info(u, "%s unit.", enable ? "Enabling" : "Disabling");
 523
 524         if (enable)
 525                 r = bus_call_method(
 526                                 bus,
 527                                 bus_systemd_mgr,
 528                                 "EnableUnitFiles",
 529                                 error,
 530                                 NULL,
 531                                 "asbb", 1,
 532                                 u->name,
 533                                 false, true);
 534         else
 535                 r = bus_call_method(
 536                                 bus,
 537                                 bus_systemd_mgr,
 538                                 "DisableUnitFiles",
 539                                 error,
 540                                 NULL,
 541                                 "asb", 1,
 542                                 u->name,
 543                                 false);
 544         if (r < 0)
 545                 return r;
 546
 547         r = bus_service_manager_reload(bus);
 548         if (r < 0)
 549                 return r;
 550
 551         return 0;
 552 }
 553
 554 static bool ntp_synced(void) {
 555         struct timex txc = {};
 556
 557         if (adjtimex(&txc) < 0)
 558                 return false;
 559
 560         /* Consider the system clock synchronized if the reported maximum error is smaller than the maximum
 561          * value (16 seconds). Ignore the STA_UNSYNC flag as it may have been set to prevent the kernel from
 562          * touching the RTC. */
 563         return txc.maxerror < 16000000;
 564 }
 565
 566 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_time, "t", now(CLOCK_REALTIME));
 567 static BUS_DEFINE_PROPERTY_GET_GLOBAL(property_get_ntp_sync, "b", ntp_synced());
 568
 569 static int property_get_rtc_time(
 570                 sd_bus *bus,
 571                 const char *path,
 572                 const char *interface,
 573                 const char *property,
 574                 sd_bus_message *reply,
 575                 void *userdata,
 576                 sd_bus_error *error) {
 577
 578         struct tm tm = {};
 579         usec_t t = 0;
 580         int r;
 581
 582         r = clock_get_hwclock(&tm);
 583         if (r == -EBUSY)
 584                 log_warning("/dev/rtc is busy. Is somebody keeping it open continuously? That's not a good idea... Returning a bogus RTC timestamp.");
 585         else if (r == -ENOENT)
 586                 log_debug("/dev/rtc not found.");
 587         else if (r < 0)
 588                 return sd_bus_error_set_errnof(error, r, "Failed to read RTC: %m");
 589         else
 590                 t = (usec_t) timegm(&tm) * USEC_PER_SEC;
 591
 592         return sd_bus_message_append(reply, "t", t);
 593 }
 594
 595 static int property_get_can_ntp(
 596                 sd_bus *bus,
 597                 const char *path,
 598                 const char *interface,
 599                 const char *property,
 600                 sd_bus_message *reply,
 601                 void *userdata,
 602                 sd_bus_error *error) {
 603
 604         Context *c = ASSERT_PTR(userdata);
 605         int r;
 606
 607         assert(bus);
 608         assert(property);
 609         assert(reply);
 610         assert(error);
 611
 612         if (c->slot_job_removed)
 613                 /* When the previous request is not finished, then assume NTP is enabled. */
 614                 return sd_bus_message_append(reply, "b", true);
 615
 616         r = context_update_ntp_status(c, bus, reply);
 617         if (r < 0)
 618                 return r;
 619
 620         return sd_bus_message_append(reply, "b", context_ntp_service_exists(c) > 0);
 621 }
 622
 623 static int property_get_ntp(
 624                 sd_bus *bus,
 625                 const char *path,
 626                 const char *interface,
 627                 const char *property,
 628                 sd_bus_message *reply,
 629                 void *userdata,
 630                 sd_bus_error *error) {
 631
 632         Context *c = ASSERT_PTR(userdata);
 633         int r;
 634
 635         assert(bus);
 636         assert(property);
 637         assert(reply);
 638         assert(error);
 639
 640         if (c->slot_job_removed)
 641                 /* When the previous request is not finished, then assume NTP is active. */
 642                 return sd_bus_message_append(reply, "b", true);
 643
 644         r = context_update_ntp_status(c, bus, reply);
 645         if (r < 0)
 646                 return r;
 647
 648         return sd_bus_message_append(reply, "b", context_ntp_service_is_active(c) > 0);
 649 }
 650
 651 static int method_set_timezone(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 652         Context *c = ASSERT_PTR(userdata);
 653         int interactive, r;
 654         const char *z;
 655
 656         assert(m);
 657
 658         r = sd_bus_message_read(m, "sb", &z, &interactive);
 659         if (r < 0)
 660                 return r;
 661
 662         if (!timezone_is_valid(z, LOG_DEBUG))
 663                 return sd_bus_error_setf(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid or not installed time zone '%s'", z);
 664
 665         if (streq_ptr(z, c->zone))
 666                 return sd_bus_reply_method_return(m, NULL);
 667
 668         r = bus_verify_polkit_async(
 669                         m,
 670                         CAP_SYS_TIME,
 671                         "org.freedesktop.timedate1.set-timezone",
 672                         NULL,
 673                         interactive,
 674                         UID_INVALID,
 675                         &c->polkit_registry,
 676                         error);
 677         if (r < 0)
 678                 return r;
 679         if (r == 0)
 680                 return 1; /* No authorization for now, but the async polkit stuff will call us again when it has it */
 681
 682         r = free_and_strdup(&c->zone, z);
 683         if (r < 0)
 684                 return r;
 685
 686         /* 1. Write new configuration file */
 687         r = context_write_data_timezone(c);
 688         if (r < 0) {
 689                 log_error_errno(r, "Failed to set time zone: %m");
 690                 return sd_bus_error_set_errnof(error, r, "Failed to set time zone: %m");
 691         }
 692
 693         /* 2. Make glibc notice the new timezone */
 694         tzset();
 695
 696         /* 3. Tell the kernel our timezone */
 697         r = clock_set_timezone(NULL);
 698         if (r < 0)
 699                 log_debug_errno(r, "Failed to tell kernel about timezone, ignoring: %m");
 700
 701         if (c->local_rtc) {
 702                 struct timespec ts;
 703                 struct tm tm;
 704
 705                 /* 4. Sync RTC from system clock, with the new delta */
 706                 assert_se(clock_gettime(CLOCK_REALTIME, &ts) == 0);
 707                 assert_se(localtime_r(&ts.tv_sec, &tm));
 708
 709                 r = clock_set_hwclock(&tm);
 710                 if (r < 0)
 711                         log_debug_errno(r, "Failed to sync time to hardware clock, ignoring: %m");
 712         }
 713
 714         log_struct(LOG_INFO,
 715                    "MESSAGE_ID=" SD_MESSAGE_TIMEZONE_CHANGE_STR,
 716                    "TIMEZONE=%s", c->zone,
 717                    "TIMEZONE_SHORTNAME=%s", tzname[daylight],
 718                    "DAYLIGHT=%i", daylight,
 719                    LOG_MESSAGE("Changed time zone to '%s' (%s).", c->zone, tzname[daylight]));
 720
 721         (void) sd_bus_emit_properties_changed(sd_bus_message_get_bus(m),
 722                                               "/org/freedesktop/timedate1", "org.freedesktop.timedate1", "Timezone",
 723                                               NULL);
 724
 725         return sd_bus_reply_method_return(m, NULL);
 726 }
 727
 728 static int method_set_local_rtc(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 729         int lrtc, fix_system, interactive;
 730         Context *c = ASSERT_PTR(userdata);
 731         struct timespec ts;
 732         int r;
 733
 734         assert(m);
 735
 736         r = sd_bus_message_read(m, "bbb", &lrtc, &fix_system, &interactive);
 737         if (r < 0)
 738                 return r;
 739
 740         if (lrtc == c->local_rtc && !fix_system)
 741                 return sd_bus_reply_method_return(m, NULL);
 742
 743         r = bus_verify_polkit_async(
 744                         m,
 745                         CAP_SYS_TIME,
 746                         "org.freedesktop.timedate1.set-local-rtc",
 747                         NULL,
 748                         interactive,
 749                         UID_INVALID,
 750                         &c->polkit_registry,
 751                         error);
 752         if (r < 0)
 753                 return r;
 754         if (r == 0)
 755                 return 1;
 756
 757         if (lrtc != c->local_rtc) {
 758                 c->local_rtc = lrtc;
 759
 760                 /* 1. Write new configuration file */
 761                 r = context_write_data_local_rtc(c);
 762                 if (r < 0) {
 763                         log_error_errno(r, "Failed to set RTC to %s: %m", lrtc ? "local" : "UTC");
 764                         return sd_bus_error_set_errnof(error, r, "Failed to set RTC to %s: %m", lrtc ? "local" : "UTC");
 765                 }
 766         }
 767
 768         /* 2. Tell the kernel our timezone */
 769         r = clock_set_timezone(NULL);
 770         if (r < 0)
 771                 log_debug_errno(r, "Failed to tell kernel about timezone, ignoring: %m");
 772
 773         /* 3. Synchronize clocks */
 774         assert_se(clock_gettime(CLOCK_REALTIME, &ts) == 0);
 775
 776         if (fix_system) {
 777                 struct tm tm;
 778
 779                 /* Sync system clock from RTC; first, initialize the timezone fields of struct tm. */
 780                 localtime_or_gmtime_r(&ts.tv_sec, &tm, !c->local_rtc);
 781
 782                 /* Override the main fields of struct tm, but not the timezone fields */
 783                 r = clock_get_hwclock(&tm);
 784                 if (r < 0)
 785                         log_debug_errno(r, "Failed to get hardware clock, ignoring: %m");
 786                 else {
 787                         /* And set the system clock with this */
 788                         ts.tv_sec = mktime_or_timegm(&tm, !c->local_rtc);
 789
 790                         if (clock_settime(CLOCK_REALTIME, &ts) < 0)
 791                                 log_debug_errno(errno, "Failed to update system clock, ignoring: %m");
 792                 }
 793
 794         } else {
 795                 struct tm tm;
 796
 797                 /* Sync RTC from system clock */
 798                 localtime_or_gmtime_r(&ts.tv_sec, &tm, !c->local_rtc);
 799
 800                 r = clock_set_hwclock(&tm);
 801                 if (r < 0)
 802                         log_debug_errno(r, "Failed to sync time to hardware clock, ignoring: %m");
 803         }
 804
 805         log_info("RTC configured to %s time.", c->local_rtc ? "local" : "UTC");
 806
 807         (void) sd_bus_emit_properties_changed(sd_bus_message_get_bus(m),
 808                                               "/org/freedesktop/timedate1", "org.freedesktop.timedate1", "LocalRTC",
 809                                               NULL);
 810
 811         return sd_bus_reply_method_return(m, NULL);
 812 }
 813
 814 static int method_set_time(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 815         sd_bus *bus = sd_bus_message_get_bus(m);
 816         char buf[FORMAT_TIMESTAMP_MAX];
 817         int relative, interactive, r;
 818         Context *c = ASSERT_PTR(userdata);
 819         int64_t utc;
 820         struct timespec ts;
 821         usec_t start;
 822         struct tm tm;
 823
 824         assert(m);
 825
 826         if (c->slot_job_removed)
 827                 return sd_bus_error_set(error, BUS_ERROR_AUTOMATIC_TIME_SYNC_ENABLED, "Previous request is not finished, refusing.");
 828
 829         r = context_update_ntp_status(c, bus, m);
 830         if (r < 0)
 831                 return sd_bus_error_set_errnof(error, r, "Failed to update context: %m");
 832
 833         if (context_ntp_service_is_active(c) > 0)
 834                 return sd_bus_error_set(error, BUS_ERROR_AUTOMATIC_TIME_SYNC_ENABLED, "Automatic time synchronization is enabled");
 835
 836         /* this only gets used if dbus does not provide a timestamp */
 837         start = now(CLOCK_MONOTONIC);
 838
 839         r = sd_bus_message_read(m, "xbb", &utc, &relative, &interactive);
 840         if (r < 0)
 841                 return r;
 842
 843         if (!relative && utc <= 0)
 844                 return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Invalid absolute time");
 845
 846         if (relative && utc == 0)
 847                 return sd_bus_reply_method_return(m, NULL);
 848
 849         if (relative) {
 850                 usec_t n, x;
 851
 852                 n = now(CLOCK_REALTIME);
 853                 x = n + utc;
 854
 855                 if ((utc > 0 && x < n) ||
 856                     (utc < 0 && x > n))
 857                         return sd_bus_error_set(error, SD_BUS_ERROR_INVALID_ARGS, "Time value overflow");
 858
 859                 timespec_store(&ts, x);
 860         } else
 861                 timespec_store(&ts, (usec_t) utc);
 862
 863         r = bus_verify_polkit_async(
 864                         m,
 865                         CAP_SYS_TIME,
 866                         "org.freedesktop.timedate1.set-time",
 867                         NULL,
 868                         interactive,
 869                         UID_INVALID,
 870                         &c->polkit_registry,
 871                         error);
 872         if (r < 0)
 873                 return r;
 874         if (r == 0)
 875                 return 1;
 876
 877         /* adjust ts for time spent in program */
 878         r = sd_bus_message_get_monotonic_usec(m, &start);
 879         /* when sd_bus_message_get_monotonic_usec() returns -ENODATA it does not modify &start */
 880         if (r < 0 && r != -ENODATA)
 881                 return r;
 882
 883         timespec_store(&ts, timespec_load(&ts) + (now(CLOCK_MONOTONIC) - start));
 884
 885         /* Set system clock */
 886         if (clock_settime(CLOCK_REALTIME, &ts) < 0) {
 887                 log_error_errno(errno, "Failed to set local time: %m");
 888                 return sd_bus_error_set_errnof(error, errno, "Failed to set local time: %m");
 889         }
 890
 891         /* Sync down to RTC */
 892         localtime_or_gmtime_r(&ts.tv_sec, &tm, !c->local_rtc);
 893
 894         r = clock_set_hwclock(&tm);
 895         if (r < 0)
 896                 log_debug_errno(r, "Failed to update hardware clock, ignoring: %m");
 897
 898         log_struct(LOG_INFO,
 899                    "MESSAGE_ID=" SD_MESSAGE_TIME_CHANGE_STR,
 900                    "REALTIME="USEC_FMT, timespec_load(&ts),
 901                    LOG_MESSAGE("Changed local time to %s", strnull(format_timestamp(buf, sizeof(buf), timespec_load(&ts)))));
 902
 903         return sd_bus_reply_method_return(m, NULL);
 904 }
 905
 906 static int method_set_ntp(sd_bus_message *m, void *userdata, sd_bus_error *error) {
 907         _cleanup_(sd_bus_slot_unrefp) sd_bus_slot *slot = NULL;
 908         sd_bus *bus = sd_bus_message_get_bus(m);
 909         Context *c = ASSERT_PTR(userdata);
 910         const UnitStatusInfo *selected = NULL;
 911         int enable, interactive, q, r;
 912
 913         assert(m);
 914         assert(bus);
 915
 916         r = sd_bus_message_read(m, "bb", &enable, &interactive);
 917         if (r < 0)
 918                 return r;
 919
 920         r = context_update_ntp_status(c, bus, m);
 921         if (r < 0)
 922                 return r;
 923
 924         if (context_ntp_service_exists(c) <= 0)
 925                 return sd_bus_error_set(error, BUS_ERROR_NO_NTP_SUPPORT, "NTP not supported");
 926
 927         r = bus_verify_polkit_async(
 928                         m,
 929                         CAP_SYS_TIME,
 930                         "org.freedesktop.timedate1.set-ntp",
 931                         NULL,
 932                         interactive,
 933                         UID_INVALID,
 934                         &c->polkit_registry,
 935                         error);
 936         if (r < 0)
 937                 return r;
 938         if (r == 0)
 939                 return 1;
 940
 941         /* This method may be called frequently. Forget the previous job if it has not completed yet. */
 942         LIST_FOREACH(units, u, c->units)
 943                 u->path = mfree(u->path);
 944
 945         if (!c->slot_job_removed) {
 946                 r = bus_match_signal_async(
 947                                 bus,
 948                                 &slot,
 949                                 bus_systemd_mgr,
 950                                 "JobRemoved",
 951                                 match_job_removed, NULL, c);
 952                 if (r < 0)
 953                         return r;
 954         }
 955
 956         if (enable)
 957                 LIST_FOREACH(units, u, c->units) {
 958                         bool enable_this_one = !selected;
 959
 960                         if (!streq(u->load_state, "loaded"))
 961                                 continue;
 962
 963                         r = unit_enable_or_disable(u, bus, error, enable_this_one);
 964                         if (r < 0)
 965                                 /* If enablement failed, don't start this unit. */
 966                                 enable_this_one = false;
 967
 968                         r = unit_start_or_stop(u, bus, error, enable_this_one);
 969                         if (r < 0)
 970                                 log_unit_warning_errno(u, r, "Failed to %s %sd NTP unit, ignoring: %m",
 971                                                        enable_this_one ? "start" : "stop",
 972                                                        enable_disable(enable_this_one));
 973                         if (enable_this_one)
 974                                 selected = u;
 975                 }
 976         else
 977                 LIST_FOREACH(units, u, c->units) {
 978                         if (!streq(u->load_state, "loaded"))
 979                                 continue;
 980
 981                         q = unit_enable_or_disable(u, bus, error, false);
 982                         if (q < 0)
 983                                 r = q;
 984
 985                         q = unit_start_or_stop(u, bus, error, false);
 986                         if (q < 0)
 987                                 r = q;
 988                 }
 989
 990         if (r < 0)
 991                 return r;
 992         if (enable && !selected)
 993                 return log_error_errno(SYNTHETIC_ERRNO(ENOENT), "No NTP service found to enable.");
 994
 995         if (slot)
 996                 c->slot_job_removed = TAKE_PTR(slot);
 997
 998         if (selected)
 999                 log_info("Set NTP to enabled (%s).", selected->name);
1000         else
1001                 log_info("Set NTP to disabled.");
1002
1003         return sd_bus_reply_method_return(m, NULL);
1004 }
1005
1006 static int method_list_timezones(sd_bus_message *m, void *userdata, sd_bus_error *error) {
1007         _cleanup_(sd_bus_message_unrefp) sd_bus_message *reply = NULL;
1008         _cleanup_strv_free_ char **zones = NULL;
1009         int r;
1010
1011         assert(m);
1012
1013         r = get_timezones(&zones);
1014         if (r < 0)
1015                 return sd_bus_error_set_errnof(error, r, "Failed to read list of time zones: %m");
1016
1017         r = sd_bus_message_new_method_return(m, &reply);
1018         if (r < 0)
1019                 return r;
1020
1021         r = sd_bus_message_append_strv(reply, zones);
1022         if (r < 0)
1023                 return r;
1024
1025         return sd_bus_send(NULL, reply, NULL);
1026 }
1027
1028 static const sd_bus_vtable timedate_vtable[] = {
1029         SD_BUS_VTABLE_START(0),
1030
1031         SD_BUS_PROPERTY("Timezone", "s", NULL, offsetof(Context, zone), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1032         SD_BUS_PROPERTY("LocalRTC", "b", bus_property_get_bool, offsetof(Context, local_rtc), SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1033         SD_BUS_PROPERTY("CanNTP", "b", property_get_can_ntp, 0, 0),
1034         SD_BUS_PROPERTY("NTP", "b", property_get_ntp, 0, SD_BUS_VTABLE_PROPERTY_EMITS_CHANGE),
1035         SD_BUS_PROPERTY("NTPSynchronized", "b", property_get_ntp_sync, 0, 0),
1036         SD_BUS_PROPERTY("TimeUSec", "t", property_get_time, 0, 0),
1037         SD_BUS_PROPERTY("RTCTimeUSec", "t", property_get_rtc_time, 0, 0),
1038
1039         SD_BUS_METHOD_WITH_ARGS("SetTime",
1040                                 SD_BUS_ARGS("x", usec_utc, "b", relative, "b", interactive),
1041                                 SD_BUS_NO_RESULT,
1042                                 method_set_time,
1043                                 SD_BUS_VTABLE_UNPRIVILEGED),
1044         SD_BUS_METHOD_WITH_ARGS("SetTimezone",
1045                                 SD_BUS_ARGS("s", timezone, "b", interactive),
1046                                 SD_BUS_NO_RESULT,
1047                                 method_set_timezone,
1048                                 SD_BUS_VTABLE_UNPRIVILEGED),
1049         SD_BUS_METHOD_WITH_ARGS("SetLocalRTC",
1050                                 SD_BUS_ARGS("b", local_rtc, "b", fix_system, "b", interactive),
1051                                 SD_BUS_NO_RESULT,
1052                                 method_set_local_rtc,
1053                                 SD_BUS_VTABLE_UNPRIVILEGED),
1054         SD_BUS_METHOD_WITH_ARGS("SetNTP",
1055                                 SD_BUS_ARGS("b", use_ntp, "b", interactive),
1056                                 SD_BUS_NO_RESULT,
1057                                 method_set_ntp,
1058                                 SD_BUS_VTABLE_UNPRIVILEGED),
1059         SD_BUS_METHOD_WITH_ARGS("ListTimezones",
1060                                 SD_BUS_NO_ARGS,
1061                                 SD_BUS_RESULT("as", timezones),
1062                                 method_list_timezones,
1063                                 SD_BUS_VTABLE_UNPRIVILEGED),
1064
1065         SD_BUS_VTABLE_END,
1066 };
1067
1068 const BusObjectImplementation manager_object = {
1069         "/org/freedesktop/timedate1",
1070         "org.freedesktop.timedate1",
1071         .vtables = BUS_VTABLES(timedate_vtable),
1072 };
1073
1074 static int connect_bus(Context *c, sd_event *event, sd_bus **_bus) {
1075         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1076         int r;
1077
1078         assert(c);
1079         assert(event);
1080         assert(_bus);
1081
1082         r = sd_bus_default_system(&bus);
1083         if (r < 0)
1084                 return log_error_errno(r, "Failed to get system bus connection: %m");
1085
1086         r = bus_add_implementation(bus, &manager_object, c);
1087         if (r < 0)
1088                 return r;
1089
1090         r = bus_log_control_api_register(bus);
1091         if (r < 0)
1092                 return r;
1093
1094         r = sd_bus_request_name_async(bus, NULL, "org.freedesktop.timedate1", 0, NULL, NULL);
1095         if (r < 0)
1096                 return log_error_errno(r, "Failed to request name: %m");
1097
1098         r = sd_bus_attach_event(bus, event, 0);
1099         if (r < 0)
1100                 return log_error_errno(r, "Failed to attach bus to event loop: %m");
1101
1102         *_bus = TAKE_PTR(bus);
1103
1104         return 0;
1105 }
1106
1107 static int run(int argc, char *argv[]) {
1108         _cleanup_(context_clear) Context context = {};
1109         _cleanup_(sd_event_unrefp) sd_event *event = NULL;
1110         _cleanup_(sd_bus_flush_close_unrefp) sd_bus *bus = NULL;
1111         int r;
1112
1113         log_setup();
1114
1115         r = service_parse_argv("systemd-timedated.service",
1116                                "Manage the system clock and timezone and NTP enablement.",
1117                                BUS_IMPLEMENTATIONS(&manager_object,
1118                                                    &log_control_object),
1119                                argc, argv);
1120         if (r <= 0)
1121                 return r;
1122
1123         umask(0022);
1124
1125         assert_se(sigprocmask_many(SIG_BLOCK, NULL, SIGTERM, SIGINT, -1) >= 0);
1126
1127         r = sd_event_default(&event);
1128         if (r < 0)
1129                 return log_error_errno(r, "Failed to allocate event loop: %m");
1130
1131         (void) sd_event_set_watchdog(event, true);
1132
1133         r = sd_event_add_signal(event, NULL, SIGINT, NULL, NULL);
1134         if (r < 0)
1135                 return log_error_errno(r, "Failed to install SIGINT handler: %m");
1136
1137         r = sd_event_add_signal(event, NULL, SIGTERM, NULL, NULL);
1138         if (r < 0)
1139                 return log_error_errno(r, "Failed to install SIGTERM handler: %m");
1140
1141         r = connect_bus(&context, event, &bus);
1142         if (r < 0)
1143                 return r;
1144
1145         (void) sd_bus_negotiate_timestamp(bus, true);
1146
1147         r = context_read_data(&context);
1148         if (r < 0)
1149                 return log_error_errno(r, "Failed to read time zone data: %m");
1150
1151         r = context_parse_ntp_services(&context);
1152         if (r < 0)
1153                 return r;
1154
1155         r = bus_event_loop_with_idle(event, bus, "org.freedesktop.timedate1", DEFAULT_EXIT_USEC, NULL, NULL);
1156         if (r < 0)
1157                 return log_error_errno(r, "Failed to run event loop: %m");
1158
1159         return 0;
1160 }
1161
1162 DEFINE_MAIN_FUNCTION(run);