1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2014 Kay Sievers, Lennart Poettering
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
29 #include <arpa/inet.h>
30 #include <netinet/in.h>
31 #include <netinet/ip.h>
32 #include <sys/timerfd.h>
33 #include <sys/timex.h>
34 #include <sys/socket.h>
36 #include <sys/prctl.h>
37 #include <sys/types.h>
42 #include "sparse-endian.h"
44 #include "socket-util.h"
46 #include "ratelimit.h"
48 #include "conf-parser.h"
50 #include "sd-resolve.h"
51 #include "sd-daemon.h"
52 #include "sd-network.h"
53 #include "event-util.h"
54 #include "network-util.h"
55 #include "clock-util.h"
56 #include "capability.h"
58 #include "timesyncd.h"
60 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
63 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
66 /* expected accuracy of time synchronization; used to adjust the poll interval */
67 #define NTP_ACCURACY_SEC 0.2
70 * "A client MUST NOT under any conditions use a poll interval less
73 #define NTP_POLL_INTERVAL_MIN_SEC 32
74 #define NTP_POLL_INTERVAL_MAX_SEC 2048
77 * Maximum delta in seconds which the system clock is gradually adjusted
78 * (slew) to approach the network time. Deltas larger that this are set by
79 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
81 #define NTP_MAX_ADJUST 0.4
83 /* NTP protocol, packet header */
84 #define NTP_LEAP_PLUSSEC 1
85 #define NTP_LEAP_MINUSSEC 2
86 #define NTP_LEAP_NOTINSYNC 3
87 #define NTP_MODE_CLIENT 3
88 #define NTP_MODE_SERVER 4
89 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
90 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
91 #define NTP_FIELD_MODE(f) ((f) & 7)
92 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
95 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
96 * in seconds relative to 0h on 1 January 1900."
98 #define OFFSET_1900_1970 2208988800UL
100 #define RETRY_USEC (30*USEC_PER_SEC)
101 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
102 #define RATELIMIT_BURST 10
104 #define TIMEOUT_USEC (10*USEC_PER_SEC)
111 struct ntp_ts_short {
121 struct ntp_ts_short root_delay;
122 struct ntp_ts_short root_dispersion;
124 struct ntp_ts reference_time;
125 struct ntp_ts origin_time;
126 struct ntp_ts recv_time;
127 struct ntp_ts trans_time;
130 static void manager_free(Manager *m);
131 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
132 #define _cleanup_manager_free_ _cleanup_(manager_freep)
134 static int manager_arm_timer(Manager *m, usec_t next);
135 static int manager_clock_watch_setup(Manager *m);
136 static int manager_connect(Manager *m);
137 static void manager_disconnect(Manager *m);
139 static double ntp_ts_to_d(const struct ntp_ts *ts) {
140 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
143 static double ts_to_d(const struct timespec *ts) {
144 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
147 static double tv_to_d(const struct timeval *tv) {
148 return tv->tv_sec + (1.0e-6 * tv->tv_usec);
151 static double square(double d) {
155 static int load_clock_timestamp(uid_t uid, gid_t gid) {
156 _cleanup_close_ int fd = -1;
157 usec_t min = TIME_EPOCH * USEC_PER_SEC;
161 /* Let's try to make sure that the clock is always
162 * monotonically increasing, by saving the clock whenever we
163 * have a new NTP time, or when we shut down, and restoring it
164 * when we start again. This is particularly helpful on
165 * systems lacking a battery backed RTC. We also will adjust
166 * the time to at least the build time of systemd. */
168 fd = open("/var/lib/systemd/clock", O_RDWR|O_CLOEXEC, 0644);
173 /* check if the recorded time is later than the compiled-in one */
176 stamp = timespec_load(&st.st_mtim);
181 /* Try to fix the access mode, so that we can still
182 touch the file after dropping priviliges */
184 fchown(fd, uid, gid);
187 /* create stamp file with the compiled-in date */
188 touch_file("/var/lib/systemd/clock", true, min, uid, gid, 0644);
190 ct = now(CLOCK_REALTIME);
193 char date[FORMAT_TIMESTAMP_MAX];
195 log_info("System clock time unset or jumped backwards, restoring from recorded timestamp: %s",
196 format_timestamp(date, sizeof(date), min));
198 if (clock_settime(CLOCK_REALTIME, timespec_store(&ts, min)) < 0)
199 log_error("Failed to restore system clock: %m");
205 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
206 _cleanup_free_ char *pretty = NULL;
207 Manager *m = userdata;
210 assert(m->current_server_name);
211 assert(m->current_server_address);
213 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
214 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
216 return manager_connect(m);
219 static int manager_send_request(Manager *m) {
220 _cleanup_free_ char *pretty = NULL;
221 struct ntp_msg ntpmsg = {
223 * "The client initializes the NTP message header, sends the request
224 * to the server, and strips the time of day from the Transmit
225 * Timestamp field of the reply. For this purpose, all the NTP
226 * header fields are set to 0, except the Mode, VN, and optional
227 * Transmit Timestamp fields."
229 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
235 assert(m->current_server_name);
236 assert(m->current_server_address);
238 m->event_timeout = sd_event_source_unref(m->event_timeout);
241 * Set transmit timestamp, remember it; the server will send that back
242 * as the origin timestamp and we have an indication that this is the
243 * matching answer to our request.
245 * The actual value does not matter, We do not care about the correct
246 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
248 assert_se(clock_gettime(CLOCK_MONOTONIC, &m->trans_time_mon) >= 0);
249 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
250 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
251 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
253 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
255 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
256 if (len == sizeof(ntpmsg)) {
258 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
260 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
261 return manager_connect(m);
264 /* re-arm timer with increasing timeout, in case the packets never arrive back */
265 if (m->retry_interval > 0) {
266 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
267 m->retry_interval *= 2;
269 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
271 r = manager_arm_timer(m, m->retry_interval);
273 log_error("Failed to rearm timer: %s", strerror(-r));
277 r = sd_event_add_time(
281 now(CLOCK_MONOTONIC) + TIMEOUT_USEC, 0,
284 log_error("Failed to arm timeout timer: %s", strerror(-r));
291 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
292 Manager *m = userdata;
296 return manager_send_request(m);
299 static int manager_arm_timer(Manager *m, usec_t next) {
303 assert(m->event_receive);
306 m->event_timer = sd_event_source_unref(m->event_timer);
310 if (m->event_timer) {
311 r = sd_event_source_set_time(m->event_timer, now(CLOCK_MONOTONIC) + next);
315 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
318 return sd_event_add_time(
322 now(CLOCK_MONOTONIC) + next, 0,
326 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
327 Manager *m = userdata;
332 manager_clock_watch_setup(m);
334 /* skip our own jumps */
341 log_info("System time changed. Resyncing.");
342 m->poll_resync = true;
343 return manager_send_request(m);
346 /* wake up when the system time changes underneath us */
347 static int manager_clock_watch_setup(Manager *m) {
349 struct itimerspec its = {
350 .it_value.tv_sec = TIME_T_MAX
357 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
358 safe_close(m->clock_watch_fd);
360 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
361 if (m->clock_watch_fd < 0) {
362 log_error("Failed to create timerfd: %m");
366 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
367 log_error("Failed to set up timerfd: %m");
371 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
373 log_error("Failed to create clock watch event source: %s", strerror(-r));
380 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
381 struct timex tmx = {};
387 * For small deltas, tell the kernel to gradually adjust the system
388 * clock to the NTP time, larger deltas are just directly set.
390 * Clear STA_UNSYNC, it will enable the kernel's 11-minute mode, which
391 * syncs the system time periodically to the hardware clock.
393 if (fabs(offset) < NTP_MAX_ADJUST) {
394 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
395 tmx.status = STA_PLL;
396 tmx.offset = offset * NSEC_PER_SEC;
397 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
400 log_debug(" adjust (slew): %+.3f sec\n", offset);
402 tmx.modes = ADJ_SETOFFSET | ADJ_NANO;
404 /* ADJ_NANO uses nanoseconds in the microseconds field */
405 tmx.time.tv_sec = (long)offset;
406 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
408 /* the kernel expects -0.3s as {-1, 7000.000.000} */
409 if (tmx.time.tv_usec < 0) {
410 tmx.time.tv_sec -= 1;
411 tmx.time.tv_usec += NSEC_PER_SEC;
415 log_debug(" adjust (jump): %+.3f sec\n", offset);
420 tmx.status |= STA_INS;
423 tmx.status |= STA_DEL;
427 r = clock_adjtime(CLOCK_REALTIME, &tmx);
431 touch("/var/lib/systemd/clock");
433 m->drift_ppm = tmx.freq / 65536;
435 log_debug(" status : %04i %s\n"
436 " time now : %li.%03llu\n"
438 " offset : %+.3f sec\n"
439 " freq offset : %+li (%i ppm)\n",
440 tmx.status, tmx.status & STA_UNSYNC ? "" : "sync",
441 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
443 (double)tmx.offset / NSEC_PER_SEC,
444 tmx.freq, m->drift_ppm);
449 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
450 unsigned int i, idx_cur, idx_new, idx_min;
458 /* ignore initial sample */
459 if (m->packet_count == 1)
462 /* store the current data in our samples array */
463 idx_cur = m->samples_idx;
464 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
465 m->samples_idx = idx_new;
466 m->samples[idx_new].offset = offset;
467 m->samples[idx_new].delay = delay;
469 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
470 jitter = m->samples_jitter;
471 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
472 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
476 for (i = 0; i < ELEMENTSOF(m->samples); i++)
477 j += square(m->samples[i].offset - m->samples[idx_min].offset);
478 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
480 /* ignore samples when resyncing */
484 /* always accept offset if we are farther off than the round-trip delay */
485 if (fabs(offset) > delay)
488 /* we need a few samples before looking at them */
489 if (m->packet_count < 4)
492 /* do not accept anything worse than the maximum possible error of the best sample */
493 if (fabs(offset) > m->samples[idx_min].delay)
496 /* compare the difference between the current offset to the previous offset and jitter */
497 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
500 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
503 if (m->poll_resync) {
504 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
505 m->poll_resync = false;
509 /* set to minimal poll interval */
510 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
511 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
515 /* increase polling interval */
516 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
517 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
518 m->poll_interval_usec *= 2;
522 /* decrease polling interval */
523 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
524 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
525 m->poll_interval_usec /= 2;
530 static bool sockaddr_equal(union sockaddr_union *a, union sockaddr_union *b) {
534 if (a->sa.sa_family != b->sa.sa_family)
537 if (a->sa.sa_family == AF_INET)
538 return a->in.sin_addr.s_addr == b->in.sin_addr.s_addr;
540 if (a->sa.sa_family == AF_INET6)
541 return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)) == 0;
546 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
547 Manager *m = userdata;
548 struct ntp_msg ntpmsg;
552 .iov_len = sizeof(ntpmsg),
555 struct cmsghdr cmsghdr;
556 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
558 union sockaddr_union server_addr;
559 struct msghdr msghdr = {
562 .msg_control = &control,
563 .msg_controllen = sizeof(control),
564 .msg_name = &server_addr,
565 .msg_namelen = sizeof(server_addr),
567 struct cmsghdr *cmsg;
568 struct timespec now_ts;
569 struct timeval *recv_time;
571 double origin, receive, trans, dest;
572 double delay, offset;
580 if (revents & (EPOLLHUP|EPOLLERR)) {
581 log_warning("Server connection returned error.");
582 return manager_connect(m);
585 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
590 log_warning("Error receiving message. Disconnecting.");
591 return manager_connect(m);
594 if (iov.iov_len < sizeof(struct ntp_msg)) {
595 log_warning("Invalid response from server. Disconnecting.");
596 return manager_connect(m);
599 if (!m->current_server_name ||
600 !m->current_server_address ||
601 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
602 log_debug("Response from unknown server.");
607 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
608 if (cmsg->cmsg_level != SOL_SOCKET)
611 switch (cmsg->cmsg_type) {
613 recv_time = (struct timeval *) CMSG_DATA(cmsg);
618 log_error("Invalid packet timestamp.");
623 log_debug("Unexpected reply. Ignoring.");
627 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
628 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
629 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
630 log_debug("Invalid reply; not our transmit time. Ignoring.");
634 m->event_timeout = sd_event_source_unref(m->event_timeout);
636 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
637 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
638 log_debug("Invalid reply, returned times before epoch. Ignoring.");
639 return manager_connect(m);
642 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC) {
643 log_debug("Server is not synchronized. Disconnecting.");
644 return manager_connect(m);
647 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
648 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
649 return manager_connect(m);
652 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
653 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
654 return manager_connect(m);
659 m->retry_interval = 0;
661 /* announce leap seconds */
662 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
664 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
670 * "Timestamp Name ID When Generated
671 * ------------------------------------------------------------
672 * Originate Timestamp T1 time request sent by client
673 * Receive Timestamp T2 time request received by server
674 * Transmit Timestamp T3 time reply sent by server
675 * Destination Timestamp T4 time reply received by client
677 * The round-trip delay, d, and system clock offset, t, are defined as:
678 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
680 assert_se(clock_gettime(CLOCK_MONOTONIC, &now_ts) >= 0);
681 origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&m->trans_time_mon)) + OFFSET_1900_1970;
682 receive = ntp_ts_to_d(&ntpmsg.recv_time);
683 trans = ntp_ts_to_d(&ntpmsg.trans_time);
684 dest = tv_to_d(recv_time) + OFFSET_1900_1970;
686 offset = ((receive - origin) + (trans - dest)) / 2;
687 delay = (dest - origin) - (trans - receive);
689 spike = manager_sample_spike_detection(m, offset, delay);
691 manager_adjust_poll(m, offset, spike);
693 log_debug("NTP response:\n"
698 " precision : %.6f sec (%d)\n"
699 " reference : %.4s\n"
704 " offset : %+.3f sec\n"
705 " delay : %+.3f sec\n"
706 " packet count : %"PRIu64"\n"
708 " poll interval: " USEC_FMT "\n",
709 NTP_FIELD_LEAP(ntpmsg.field),
710 NTP_FIELD_VERSION(ntpmsg.field),
711 NTP_FIELD_MODE(ntpmsg.field),
713 exp2(ntpmsg.precision), ntpmsg.precision,
714 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
715 origin - OFFSET_1900_1970,
716 receive - OFFSET_1900_1970,
717 trans - OFFSET_1900_1970,
718 dest - OFFSET_1900_1970,
721 m->samples_jitter, spike ? " spike" : "",
722 m->poll_interval_usec / USEC_PER_SEC);
726 r = manager_adjust_clock(m, offset, leap_sec);
728 log_error("Failed to call clock_adjtime(): %m");
731 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
732 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
733 spike ? " (ignored)" : "");
735 r = manager_arm_timer(m, m->poll_interval_usec);
737 log_error("Failed to rearm timer: %s", strerror(-r));
744 static int manager_listen_setup(Manager *m) {
745 union sockaddr_union addr = {};
746 static const int tos = IPTOS_LOWDELAY;
747 static const int on = 1;
752 assert(m->server_socket < 0);
753 assert(!m->event_receive);
754 assert(m->current_server_address);
756 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
758 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
759 if (m->server_socket < 0)
762 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
766 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
770 setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
772 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
775 static int manager_begin(Manager *m) {
776 _cleanup_free_ char *pretty = NULL;
780 assert_return(m->current_server_name, -EHOSTUNREACH);
781 assert_return(m->current_server_address, -EHOSTUNREACH);
783 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
785 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
786 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
787 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
789 r = manager_listen_setup(m);
791 log_warning("Failed to setup connection socket: %s", strerror(-r));
795 r = manager_clock_watch_setup(m);
799 return manager_send_request(m);
802 static void server_name_flush_addresses(ServerName *n) {
807 while ((a = n->addresses)) {
808 LIST_REMOVE(addresses, n->addresses, a);
813 static void manager_flush_names(Manager *m) {
818 while ((n = m->servers)) {
819 LIST_REMOVE(names, m->servers, n);
821 server_name_flush_addresses(n);
826 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
827 Manager *m = userdata;
828 ServerAddress *a, *last = NULL;
832 assert(m->current_server_name);
834 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
837 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
840 return manager_connect(m);
843 server_name_flush_addresses(m->current_server_name);
845 for (; ai; ai = ai->ai_next) {
846 _cleanup_free_ char *pretty = NULL;
849 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
850 assert(ai->ai_addrlen <= sizeof(union sockaddr_union));
852 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
853 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
857 a = new0(ServerAddress, 1);
861 memcpy(&a->sockaddr, ai->ai_addr, ai->ai_addrlen);
862 a->socklen = ai->ai_addrlen;
864 LIST_INSERT_AFTER(addresses, m->current_server_name->addresses, last, a);
867 sockaddr_pretty(&a->sockaddr.sa, a->socklen, true, &pretty);
868 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
871 if (!m->current_server_name->addresses) {
872 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
875 return manager_connect(m);
878 m->current_server_address = m->current_server_name->addresses;
880 return manager_begin(m);
883 static int manager_retry(sd_event_source *source, usec_t usec, void *userdata) {
884 Manager *m = userdata;
888 return manager_connect(m);
891 static int manager_connect(Manager *m) {
893 struct addrinfo hints = {
894 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
895 .ai_socktype = SOCK_DGRAM,
901 manager_disconnect(m);
903 m->event_retry = sd_event_source_unref(m->event_retry);
904 if (!ratelimit_test(&m->ratelimit)) {
905 log_debug("Slowing down attempts to contact servers.");
907 r = sd_event_add_time(m->event, &m->event_retry, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + RETRY_USEC, 0, manager_retry, m);
909 log_error("Failed to create retry timer: %s", strerror(-r));
916 /* If we already are operating on some address, switch to the
918 if (m->current_server_address && m->current_server_address->addresses_next)
919 m->current_server_address = m->current_server_address->addresses_next;
921 /* Hmm, we are through all addresses, let's look for the next host instead */
922 m->current_server_address = NULL;
924 if (m->current_server_name && m->current_server_name->names_next)
925 m->current_server_name = m->current_server_name->names_next;
928 m->current_server_name = NULL;
929 log_debug("No server found.");
933 m->current_server_name = m->servers;
936 /* Tell the resolver to reread /etc/resolv.conf, in
937 * case it changed. */
940 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
942 log_error("Failed to create resolver: %s", strerror(-r));
949 r = manager_begin(m);
956 static int manager_add_server(Manager *m, const char *server) {
957 ServerName *n, *tail;
962 n = new0(ServerName, 1);
966 n->string = strdup(server);
972 LIST_FIND_TAIL(names, m->servers, tail);
973 LIST_INSERT_AFTER(names, m->servers, tail, n);
978 static int manager_add_server_string(Manager *m, const char *string) {
986 FOREACH_WORD_QUOTED(w, l, string, state) {
992 r = manager_add_server(m, t);
994 log_error("Failed to add server %s to configuration, ignoring: %s", t, strerror(-r));
1000 static void manager_disconnect(Manager *m) {
1003 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
1005 m->event_timer = sd_event_source_unref(m->event_timer);
1007 m->event_receive = sd_event_source_unref(m->event_receive);
1008 m->server_socket = safe_close(m->server_socket);
1010 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
1011 m->clock_watch_fd = safe_close(m->clock_watch_fd);
1013 m->event_timeout = sd_event_source_unref(m->event_timeout);
1015 sd_notifyf(false, "STATUS=Idle.");
1018 static int manager_new(Manager **ret) {
1019 _cleanup_manager_free_ Manager *m = NULL;
1024 m = new0(Manager, 1);
1028 m->server_socket = m->clock_watch_fd = -1;
1030 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1032 r = sd_event_default(&m->event);
1036 sd_event_set_watchdog(m->event, true);
1038 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1039 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1041 r = sd_resolve_default(&m->resolve);
1045 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1049 r = manager_clock_watch_setup(m);
1059 static void manager_free(Manager *m) {
1063 manager_disconnect(m);
1064 manager_flush_names(m);
1066 sd_event_source_unref(m->event_retry);
1068 sd_event_source_unref(m->network_event_source);
1069 sd_network_monitor_unref(m->network_monitor);
1071 sd_resolve_unref(m->resolve);
1072 sd_event_unref(m->event);
1077 int config_parse_servers(
1079 const char *filename,
1081 const char *section,
1082 unsigned section_line,
1089 Manager *m = userdata;
1095 manager_flush_names(m);
1096 manager_add_server_string(m, rvalue);
1101 static int manager_parse_config_file(Manager *m) {
1102 static const char fn[] = "/etc/systemd/timesyncd.conf";
1103 _cleanup_fclose_ FILE *f = NULL;
1108 f = fopen(fn, "re");
1110 if (errno == ENOENT)
1113 log_warning("Failed to open configuration file %s: %m", fn);
1117 r = config_parse(NULL, fn, f, "Time\0", config_item_perf_lookup,
1118 (void*) timesyncd_gperf_lookup, false, false, m);
1120 log_warning("Failed to parse configuration file: %s", strerror(-r));
1125 static bool network_is_online(void) {
1126 _cleanup_free_ char *state = NULL;
1129 r = sd_network_get_operational_state(&state);
1130 if (r >= 0 && STR_IN_SET(state, "routable", "degraded"))
1136 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents,
1138 Manager *m = userdata;
1139 bool connected, online;
1144 /* check if the machine is online */
1145 online = network_is_online();
1147 /* check if the client is currently connected */
1148 connected = (m->server_socket != -1);
1150 if (connected && !online) {
1151 log_info("No network connectivity, watching for changes.");
1152 manager_disconnect(m);
1153 } else if (!connected && online) {
1154 log_info("Network configuration changed, trying to establish connection.");
1155 if (m->current_server_address) {
1156 r = manager_begin(m);
1160 r = manager_connect(m);
1166 sd_network_monitor_flush(m->network_monitor);
1171 static int manager_network_monitor_listen(Manager *m) {
1172 _cleanup_event_source_unref_ sd_event_source *event_source = NULL;
1173 _cleanup_network_monitor_unref_ sd_network_monitor *monitor = NULL;
1176 r = sd_network_monitor_new(NULL, &monitor);
1180 fd = sd_network_monitor_get_fd(monitor);
1184 events = sd_network_monitor_get_events(monitor);
1188 r = sd_event_add_io(m->event, &event_source, fd, events,
1189 &manager_network_event_handler, m);
1193 m->network_monitor = monitor;
1194 m->network_event_source = event_source;
1196 event_source = NULL;
1201 int main(int argc, char *argv[]) {
1202 const char *user = "systemd-timesync";
1203 _cleanup_manager_free_ Manager *m = NULL;
1209 log_error("This program does not take arguments.");
1210 return EXIT_FAILURE;
1213 log_set_target(LOG_TARGET_AUTO);
1214 log_set_facility(LOG_CRON);
1215 log_parse_environment();
1220 r = get_user_creds(&user, &uid, &gid, NULL, NULL);
1222 log_error("Cannot resolve user name %s: %s", user, strerror(-r));
1226 r = load_clock_timestamp(uid, gid);
1230 r = drop_privileges(uid, gid, (1ULL << CAP_SYS_TIME));
1234 assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
1236 r = manager_new(&m);
1238 log_error("Failed to allocate manager: %s", strerror(-r));
1242 manager_add_server_string(m, NTP_SERVERS);
1243 manager_parse_config_file(m);
1245 r = manager_network_monitor_listen(m);
1247 log_error("Failed to listen to networkd events: %s", strerror(-r));
1251 log_debug("systemd-timesyncd running as pid %lu", (unsigned long) getpid());
1252 sd_notify(false, "READY=1");
1254 if (network_is_online()) {
1255 r = manager_connect(m);
1260 r = sd_event_loop(m->event);
1262 log_error("Failed to run event loop: %s", strerror(-r));
1266 sd_event_get_exit_code(m->event, &r);
1268 /* if we got an authoritative time, store it in the file system */
1270 touch("/var/lib/systemd/clock");
1273 sd_notify(false, "STATUS=Shutting down...");
1275 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;