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