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"
49 #include "sd-daemon.h"
50 #include "event-util.h"
51 #include "network-util.h"
52 #include "clock-util.h"
53 #include "capability.h"
55 #include "timesyncd-conf.h"
56 #include "timesyncd-manager.h"
57 #include "time-util.h"
60 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
63 /* expected accuracy of time synchronization; used to adjust the poll interval */
64 #define NTP_ACCURACY_SEC 0.2
67 * "A client MUST NOT under any conditions use a poll interval less
70 #define NTP_POLL_INTERVAL_MIN_SEC 32
71 #define NTP_POLL_INTERVAL_MAX_SEC 2048
74 * Maximum delta in seconds which the system clock is gradually adjusted
75 * (slew) to approach the network time. Deltas larger that this are set by
76 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
78 #define NTP_MAX_ADJUST 0.4
80 /* NTP protocol, packet header */
81 #define NTP_LEAP_PLUSSEC 1
82 #define NTP_LEAP_MINUSSEC 2
83 #define NTP_LEAP_NOTINSYNC 3
84 #define NTP_MODE_CLIENT 3
85 #define NTP_MODE_SERVER 4
86 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
87 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
88 #define NTP_FIELD_MODE(f) ((f) & 7)
89 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
91 /* Maximum acceptable root distance in seconds. */
92 #define NTP_MAX_ROOT_DISTANCE 5.0
94 /* Maximum number of missed replies before selecting another source. */
95 #define NTP_MAX_MISSED_REPLIES 2
98 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
99 * in seconds relative to 0h on 1 January 1900."
101 #define OFFSET_1900_1970 2208988800UL
103 #define RETRY_USEC (30*USEC_PER_SEC)
104 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
105 #define RATELIMIT_BURST 10
107 #define TIMEOUT_USEC (10*USEC_PER_SEC)
114 struct ntp_ts_short {
124 struct ntp_ts_short root_delay;
125 struct ntp_ts_short root_dispersion;
127 struct ntp_ts reference_time;
128 struct ntp_ts origin_time;
129 struct ntp_ts recv_time;
130 struct ntp_ts trans_time;
133 static int manager_arm_timer(Manager *m, usec_t next);
134 static int manager_clock_watch_setup(Manager *m);
135 static int manager_listen_setup(Manager *m);
136 static void manager_listen_stop(Manager *m);
138 static double ntp_ts_short_to_d(const struct ntp_ts_short *ts) {
139 return be16toh(ts->sec) + (be16toh(ts->frac) / 65536.0);
142 static double ntp_ts_to_d(const struct ntp_ts *ts) {
143 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
146 static double ts_to_d(const struct timespec *ts) {
147 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
150 static double square(double d) {
154 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
155 _cleanup_free_ char *pretty = NULL;
156 Manager *m = userdata;
159 assert(m->current_server_name);
160 assert(m->current_server_address);
162 server_address_pretty(m->current_server_address, &pretty);
163 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
165 return manager_connect(m);
168 static int manager_send_request(Manager *m) {
169 _cleanup_free_ char *pretty = NULL;
170 struct ntp_msg ntpmsg = {
172 * "The client initializes the NTP message header, sends the request
173 * to the server, and strips the time of day from the Transmit
174 * Timestamp field of the reply. For this purpose, all the NTP
175 * header fields are set to 0, except the Mode, VN, and optional
176 * Transmit Timestamp fields."
178 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
184 assert(m->current_server_name);
185 assert(m->current_server_address);
187 m->event_timeout = sd_event_source_unref(m->event_timeout);
189 r = manager_listen_setup(m);
191 return log_warning_errno(r, "Failed to setup connection socket: %m");
194 * Set transmit timestamp, remember it; the server will send that back
195 * as the origin timestamp and we have an indication that this is the
196 * matching answer to our request.
198 * The actual value does not matter, We do not care about the correct
199 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
201 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
202 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
203 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
204 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
206 server_address_pretty(m->current_server_address, &pretty);
208 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
209 if (len == sizeof(ntpmsg)) {
211 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
213 log_debug_errno(errno, "Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
214 return manager_connect(m);
217 /* re-arm timer with increasing timeout, in case the packets never arrive back */
218 if (m->retry_interval > 0) {
219 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
220 m->retry_interval *= 2;
222 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
224 r = manager_arm_timer(m, m->retry_interval);
226 return log_error_errno(r, "Failed to rearm timer: %m");
229 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
230 r = sd_event_add_time(
233 clock_boottime_or_monotonic(),
234 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
237 return log_error_errno(r, "Failed to arm timeout timer: %m");
243 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
244 Manager *m = userdata;
248 return manager_send_request(m);
251 static int manager_arm_timer(Manager *m, usec_t next) {
257 m->event_timer = sd_event_source_unref(m->event_timer);
261 if (m->event_timer) {
262 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
266 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
269 return sd_event_add_time(
272 clock_boottime_or_monotonic(),
273 now(clock_boottime_or_monotonic()) + next, 0,
277 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
278 Manager *m = userdata;
283 manager_clock_watch_setup(m);
285 /* skip our own jumps */
292 log_info("System time changed. Resyncing.");
293 m->poll_resync = true;
295 return manager_send_request(m);
298 /* wake up when the system time changes underneath us */
299 static int manager_clock_watch_setup(Manager *m) {
301 struct itimerspec its = {
302 .it_value.tv_sec = TIME_T_MAX
309 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
310 safe_close(m->clock_watch_fd);
312 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
313 if (m->clock_watch_fd < 0)
314 return log_error_errno(errno, "Failed to create timerfd: %m");
316 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0)
317 return log_error_errno(errno, "Failed to set up timerfd: %m");
319 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
321 return log_error_errno(r, "Failed to create clock watch event source: %m");
326 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
327 struct timex tmx = {};
333 * For small deltas, tell the kernel to gradually adjust the system
334 * clock to the NTP time, larger deltas are just directly set.
336 if (fabs(offset) < NTP_MAX_ADJUST) {
337 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
338 tmx.status = STA_PLL;
339 tmx.offset = offset * NSEC_PER_SEC;
340 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
343 log_debug(" adjust (slew): %+.3f sec", offset);
345 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
347 /* ADJ_NANO uses nanoseconds in the microseconds field */
348 tmx.time.tv_sec = (long)offset;
349 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
351 /* the kernel expects -0.3s as {-1, 7000.000.000} */
352 if (tmx.time.tv_usec < 0) {
353 tmx.time.tv_sec -= 1;
354 tmx.time.tv_usec += NSEC_PER_SEC;
358 log_debug(" adjust (jump): %+.3f sec", offset);
362 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
363 * which syncs the system time periodically to the RTC.
365 * In case the RTC runs in local time, never touch the RTC,
366 * we have no way to properly handle daylight saving changes and
367 * mobile devices moving between time zones.
369 if (m->rtc_local_time)
370 tmx.status |= STA_UNSYNC;
374 tmx.status |= STA_INS;
377 tmx.status |= STA_DEL;
381 r = clock_adjtime(CLOCK_REALTIME, &tmx);
385 touch("/var/lib/systemd/clock");
387 m->drift_ppm = tmx.freq / 65536;
389 log_debug(" status : %04i %s\n"
390 " time now : %li.%03llu\n"
392 " offset : %+.3f sec\n"
393 " freq offset : %+li (%i ppm)\n",
394 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
395 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
397 (double)tmx.offset / NSEC_PER_SEC,
398 tmx.freq, m->drift_ppm);
403 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
404 unsigned int i, idx_cur, idx_new, idx_min;
412 /* ignore initial sample */
413 if (m->packet_count == 1)
416 /* store the current data in our samples array */
417 idx_cur = m->samples_idx;
418 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
419 m->samples_idx = idx_new;
420 m->samples[idx_new].offset = offset;
421 m->samples[idx_new].delay = delay;
423 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
424 jitter = m->samples_jitter;
425 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
426 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
430 for (i = 0; i < ELEMENTSOF(m->samples); i++)
431 j += square(m->samples[i].offset - m->samples[idx_min].offset);
432 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
434 /* ignore samples when resyncing */
438 /* always accept offset if we are farther off than the round-trip delay */
439 if (fabs(offset) > delay)
442 /* we need a few samples before looking at them */
443 if (m->packet_count < 4)
446 /* do not accept anything worse than the maximum possible error of the best sample */
447 if (fabs(offset) > m->samples[idx_min].delay)
450 /* compare the difference between the current offset to the previous offset and jitter */
451 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
454 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
457 if (m->poll_resync) {
458 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
459 m->poll_resync = false;
463 /* set to minimal poll interval */
464 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
465 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
469 /* increase polling interval */
470 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
471 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
472 m->poll_interval_usec *= 2;
476 /* decrease polling interval */
477 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
478 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
479 m->poll_interval_usec /= 2;
484 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
485 Manager *m = userdata;
486 struct ntp_msg ntpmsg;
490 .iov_len = sizeof(ntpmsg),
493 struct cmsghdr cmsghdr;
494 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
496 union sockaddr_union server_addr;
497 struct msghdr msghdr = {
500 .msg_control = &control,
501 .msg_controllen = sizeof(control),
502 .msg_name = &server_addr,
503 .msg_namelen = sizeof(server_addr),
505 struct cmsghdr *cmsg;
506 struct timespec *recv_time;
508 double origin, receive, trans, dest;
509 double delay, offset;
510 double root_distance;
518 if (revents & (EPOLLHUP|EPOLLERR)) {
519 log_warning("Server connection returned error.");
520 return manager_connect(m);
523 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
528 log_warning("Error receiving message. Disconnecting.");
529 return manager_connect(m);
532 if (iov.iov_len < sizeof(struct ntp_msg)) {
533 log_warning("Invalid response from server. Disconnecting.");
534 return manager_connect(m);
537 if (!m->current_server_name ||
538 !m->current_server_address ||
539 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
540 log_debug("Response from unknown server.");
545 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
546 if (cmsg->cmsg_level != SOL_SOCKET)
549 switch (cmsg->cmsg_type) {
550 case SCM_TIMESTAMPNS:
551 recv_time = (struct timespec *) CMSG_DATA(cmsg);
556 log_error("Invalid packet timestamp.");
561 log_debug("Unexpected reply. Ignoring.");
565 m->missed_replies = 0;
567 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
568 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
569 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
570 log_debug("Invalid reply; not our transmit time. Ignoring.");
574 m->event_timeout = sd_event_source_unref(m->event_timeout);
576 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
577 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
578 log_debug("Invalid reply, returned times before epoch. Ignoring.");
579 return manager_connect(m);
582 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
583 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
584 log_debug("Server is not synchronized. Disconnecting.");
585 return manager_connect(m);
588 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
589 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
590 return manager_connect(m);
593 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
594 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
595 return manager_connect(m);
598 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
599 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
600 log_debug("Server has too large root distance. Disconnecting.");
601 return manager_connect(m);
606 m->retry_interval = 0;
609 manager_listen_stop(m);
611 /* announce leap seconds */
612 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
614 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
620 * "Timestamp Name ID When Generated
621 * ------------------------------------------------------------
622 * Originate Timestamp T1 time request sent by client
623 * Receive Timestamp T2 time request received by server
624 * Transmit Timestamp T3 time reply sent by server
625 * Destination Timestamp T4 time reply received by client
627 * The round-trip delay, d, and system clock offset, t, are defined as:
628 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
630 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
631 receive = ntp_ts_to_d(&ntpmsg.recv_time);
632 trans = ntp_ts_to_d(&ntpmsg.trans_time);
633 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
635 offset = ((receive - origin) + (trans - dest)) / 2;
636 delay = (dest - origin) - (trans - receive);
638 spike = manager_sample_spike_detection(m, offset, delay);
640 manager_adjust_poll(m, offset, spike);
642 log_debug("NTP response:\n"
647 " precision : %.6f sec (%d)\n"
648 " root distance: %.6f sec\n"
649 " reference : %.4s\n"
654 " offset : %+.3f sec\n"
655 " delay : %+.3f sec\n"
656 " packet count : %"PRIu64"\n"
658 " poll interval: " USEC_FMT "\n",
659 NTP_FIELD_LEAP(ntpmsg.field),
660 NTP_FIELD_VERSION(ntpmsg.field),
661 NTP_FIELD_MODE(ntpmsg.field),
663 exp2(ntpmsg.precision), ntpmsg.precision,
665 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
666 origin - OFFSET_1900_1970,
667 receive - OFFSET_1900_1970,
668 trans - OFFSET_1900_1970,
669 dest - OFFSET_1900_1970,
672 m->samples_jitter, spike ? " spike" : "",
673 m->poll_interval_usec / USEC_PER_SEC);
677 r = manager_adjust_clock(m, offset, leap_sec);
679 log_error_errno(errno, "Failed to call clock_adjtime(): %m");
682 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
683 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
684 spike ? " (ignored)" : "");
686 r = manager_arm_timer(m, m->poll_interval_usec);
688 return log_error_errno(r, "Failed to rearm timer: %m");
693 static int manager_listen_setup(Manager *m) {
694 union sockaddr_union addr = {};
695 static const int tos = IPTOS_LOWDELAY;
696 static const int on = 1;
701 if (m->server_socket >= 0)
704 assert(!m->event_receive);
705 assert(m->current_server_address);
707 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
709 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
710 if (m->server_socket < 0)
713 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
717 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
721 (void) setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
723 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
726 static void manager_listen_stop(Manager *m) {
729 m->event_receive = sd_event_source_unref(m->event_receive);
730 m->server_socket = safe_close(m->server_socket);
733 static int manager_begin(Manager *m) {
734 _cleanup_free_ char *pretty = NULL;
738 assert_return(m->current_server_name, -EHOSTUNREACH);
739 assert_return(m->current_server_address, -EHOSTUNREACH);
741 m->missed_replies = NTP_MAX_MISSED_REPLIES;
742 if (m->poll_interval_usec == 0)
743 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
745 server_address_pretty(m->current_server_address, &pretty);
746 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
747 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
749 r = manager_clock_watch_setup(m);
753 return manager_send_request(m);
756 void manager_set_server_name(Manager *m, ServerName *n) {
759 if (m->current_server_name == n)
762 m->current_server_name = n;
763 m->current_server_address = NULL;
765 manager_disconnect(m);
768 log_debug("Selected server %s.", n->string);
771 void manager_set_server_address(Manager *m, ServerAddress *a) {
774 if (m->current_server_address == a)
777 m->current_server_address = a;
778 /* If a is NULL, we are just clearing the address, without
779 * changing the name. Keep the existing name in that case. */
781 m->current_server_name = a->name;
783 manager_disconnect(m);
786 _cleanup_free_ char *pretty = NULL;
787 server_address_pretty(a, &pretty);
788 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
792 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
793 Manager *m = userdata;
798 assert(m->current_server_name);
800 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
803 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
806 return manager_connect(m);
809 for (; ai; ai = ai->ai_next) {
810 _cleanup_free_ char *pretty = NULL;
814 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
816 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
817 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
821 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
823 return log_error_errno(r, "Failed to add server address: %m");
825 server_address_pretty(a, &pretty);
826 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
829 if (!m->current_server_name->addresses) {
830 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
833 return manager_connect(m);
836 manager_set_server_address(m, m->current_server_name->addresses);
838 return manager_begin(m);
841 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
842 Manager *m = userdata;
846 return manager_connect(m);
849 int manager_connect(Manager *m) {
854 manager_disconnect(m);
856 m->event_retry = sd_event_source_unref(m->event_retry);
857 if (!ratelimit_test(&m->ratelimit)) {
858 log_debug("Slowing down attempts to contact servers.");
860 r = sd_event_add_time(m->event, &m->event_retry, clock_boottime_or_monotonic(), now(clock_boottime_or_monotonic()) + RETRY_USEC, 0, manager_retry_connect, m);
862 return log_error_errno(r, "Failed to create retry timer: %m");
867 /* If we already are operating on some address, switch to the
869 if (m->current_server_address && m->current_server_address->addresses_next)
870 manager_set_server_address(m, m->current_server_address->addresses_next);
872 struct addrinfo hints = {
873 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
874 .ai_socktype = SOCK_DGRAM,
877 /* Hmm, we are through all addresses, let's look for the next host instead */
878 if (m->current_server_name && m->current_server_name->names_next)
879 manager_set_server_name(m, m->current_server_name->names_next);
884 /* Our current server name list is exhausted,
885 * let's find the next one to iterate. First
886 * we try the system list, then the link list.
887 * After having processed the link list we
888 * jump back to the system list. However, if
889 * both lists are empty, we change to the
891 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
892 f = m->system_servers;
898 f = m->system_servers;
904 f = m->fallback_servers;
907 manager_set_server_name(m, NULL);
908 log_debug("No server found.");
912 if (restart && !m->exhausted_servers && m->poll_interval_usec) {
913 log_debug("Waiting after exhausting servers.");
914 r = sd_event_add_time(m->event, &m->event_retry, clock_boottime_or_monotonic(), now(clock_boottime_or_monotonic()) + m->poll_interval_usec, 0, manager_retry_connect, m);
916 return log_error_errno(r, "Failed to create retry timer: %m");
918 m->exhausted_servers = true;
920 /* Increase the polling interval */
921 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
922 m->poll_interval_usec *= 2;
927 m->exhausted_servers = false;
929 manager_set_server_name(m, f);
932 /* Tell the resolver to reread /etc/resolv.conf, in
933 * case it changed. */
936 /* Flush out any previously resolved addresses */
937 server_name_flush_addresses(m->current_server_name);
939 log_debug("Resolving %s...", m->current_server_name->string);
941 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
943 return log_error_errno(r, "Failed to create resolver: %m");
948 r = manager_begin(m);
955 void manager_disconnect(Manager *m) {
958 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
960 m->event_timer = sd_event_source_unref(m->event_timer);
962 manager_listen_stop(m);
964 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
965 m->clock_watch_fd = safe_close(m->clock_watch_fd);
967 m->event_timeout = sd_event_source_unref(m->event_timeout);
969 sd_notifyf(false, "STATUS=Idle.");
972 void manager_flush_server_names(Manager *m, ServerType t) {
975 if (t == SERVER_SYSTEM)
976 while (m->system_servers)
977 server_name_free(m->system_servers);
979 if (t == SERVER_LINK)
980 while (m->link_servers)
981 server_name_free(m->link_servers);
983 if (t == SERVER_FALLBACK)
984 while (m->fallback_servers)
985 server_name_free(m->fallback_servers);
988 void manager_free(Manager *m) {
992 manager_disconnect(m);
993 manager_flush_server_names(m, SERVER_SYSTEM);
994 manager_flush_server_names(m, SERVER_LINK);
995 manager_flush_server_names(m, SERVER_FALLBACK);
997 sd_event_source_unref(m->event_retry);
999 sd_event_source_unref(m->network_event_source);
1000 sd_network_monitor_unref(m->network_monitor);
1002 sd_resolve_unref(m->resolve);
1003 sd_event_unref(m->event);
1008 static int manager_network_read_link_servers(Manager *m) {
1009 _cleanup_strv_free_ char **ntp = NULL;
1016 r = sd_network_get_ntp(&ntp);
1020 LIST_FOREACH(names, n, m->link_servers)
1023 STRV_FOREACH(i, ntp) {
1026 LIST_FOREACH(names, n, m->link_servers)
1027 if (streq(n->string, *i)) {
1034 r = server_name_new(m, NULL, SERVER_LINK, *i);
1040 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1042 server_name_free(n);
1047 manager_flush_server_names(m, SERVER_LINK);
1051 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1052 Manager *m = userdata;
1053 bool connected, online;
1058 sd_network_monitor_flush(m->network_monitor);
1060 manager_network_read_link_servers(m);
1062 /* check if the machine is online */
1063 online = network_is_online();
1065 /* check if the client is currently connected */
1066 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1068 if (connected && !online) {
1069 log_info("No network connectivity, watching for changes.");
1070 manager_disconnect(m);
1072 } else if (!connected && online) {
1073 log_info("Network configuration changed, trying to establish connection.");
1075 if (m->current_server_address)
1076 r = manager_begin(m);
1078 r = manager_connect(m);
1086 static int manager_network_monitor_listen(Manager *m) {
1091 r = sd_network_monitor_new(&m->network_monitor, NULL);
1095 fd = sd_network_monitor_get_fd(m->network_monitor);
1099 events = sd_network_monitor_get_events(m->network_monitor);
1103 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1110 int manager_new(Manager **ret) {
1111 _cleanup_(manager_freep) Manager *m = NULL;
1116 m = new0(Manager, 1);
1120 m->server_socket = m->clock_watch_fd = -1;
1122 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1124 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1128 r = sd_event_default(&m->event);
1132 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1133 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1135 sd_event_set_watchdog(m->event, true);
1137 r = sd_resolve_default(&m->resolve);
1141 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1145 r = manager_network_monitor_listen(m);
1149 manager_network_read_link_servers(m);