src/timedate/timedated.c

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