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);
136 static double ntp_ts_short_to_d(const struct ntp_ts_short *ts) {
137 return be16toh(ts->sec) + (be16toh(ts->frac) / 65536.0);
140 static double ntp_ts_to_d(const struct ntp_ts *ts) {
141 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
144 static double ts_to_d(const struct timespec *ts) {
145 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
148 static double square(double d) {
152 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
153 _cleanup_free_ char *pretty = NULL;
154 Manager *m = userdata;
157 assert(m->current_server_name);
158 assert(m->current_server_address);
160 server_address_pretty(m->current_server_address, &pretty);
161 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
163 return manager_connect(m);
166 static int manager_send_request(Manager *m) {
167 _cleanup_free_ char *pretty = NULL;
168 struct ntp_msg ntpmsg = {
170 * "The client initializes the NTP message header, sends the request
171 * to the server, and strips the time of day from the Transmit
172 * Timestamp field of the reply. For this purpose, all the NTP
173 * header fields are set to 0, except the Mode, VN, and optional
174 * Transmit Timestamp fields."
176 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
182 assert(m->current_server_name);
183 assert(m->current_server_address);
185 m->event_timeout = sd_event_source_unref(m->event_timeout);
188 * Set transmit timestamp, remember it; the server will send that back
189 * as the origin timestamp and we have an indication that this is the
190 * matching answer to our request.
192 * The actual value does not matter, We do not care about the correct
193 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
195 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
196 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
197 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
198 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
200 server_address_pretty(m->current_server_address, &pretty);
202 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
203 if (len == sizeof(ntpmsg)) {
205 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
207 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
208 return manager_connect(m);
211 /* re-arm timer with increasing timeout, in case the packets never arrive back */
212 if (m->retry_interval > 0) {
213 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
214 m->retry_interval *= 2;
216 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
218 r = manager_arm_timer(m, m->retry_interval);
220 log_error("Failed to rearm timer: %s", strerror(-r));
225 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
226 r = sd_event_add_time(
229 clock_boottime_or_monotonic(),
230 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
233 log_error("Failed to arm timeout timer: %s", strerror(-r));
241 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
242 Manager *m = userdata;
246 return manager_send_request(m);
249 static int manager_arm_timer(Manager *m, usec_t next) {
253 assert(m->event_receive);
256 m->event_timer = sd_event_source_unref(m->event_timer);
260 if (m->event_timer) {
261 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
265 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
268 return sd_event_add_time(
271 clock_boottime_or_monotonic(),
272 now(clock_boottime_or_monotonic()) + next, 0,
276 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
277 Manager *m = userdata;
282 manager_clock_watch_setup(m);
284 /* skip our own jumps */
291 log_info("System time changed. Resyncing.");
292 m->poll_resync = true;
294 return manager_send_request(m);
297 /* wake up when the system time changes underneath us */
298 static int manager_clock_watch_setup(Manager *m) {
300 struct itimerspec its = {
301 .it_value.tv_sec = TIME_T_MAX
308 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
309 safe_close(m->clock_watch_fd);
311 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
312 if (m->clock_watch_fd < 0) {
313 log_error("Failed to create timerfd: %m");
317 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
318 log_error("Failed to set up timerfd: %m");
322 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
324 log_error("Failed to create clock watch event source: %s", strerror(-r));
331 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
332 struct timex tmx = {};
338 * For small deltas, tell the kernel to gradually adjust the system
339 * clock to the NTP time, larger deltas are just directly set.
341 if (fabs(offset) < NTP_MAX_ADJUST) {
342 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
343 tmx.status = STA_PLL;
344 tmx.offset = offset * NSEC_PER_SEC;
345 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
348 log_debug(" adjust (slew): %+.3f sec\n", offset);
350 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
352 /* ADJ_NANO uses nanoseconds in the microseconds field */
353 tmx.time.tv_sec = (long)offset;
354 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
356 /* the kernel expects -0.3s as {-1, 7000.000.000} */
357 if (tmx.time.tv_usec < 0) {
358 tmx.time.tv_sec -= 1;
359 tmx.time.tv_usec += NSEC_PER_SEC;
363 log_debug(" adjust (jump): %+.3f sec\n", offset);
367 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
368 * which syncs the system time periodically to the RTC.
370 * In case the RTC runs in local time, never touch the RTC,
371 * we have no way to properly handle daylight saving changes and
372 * mobile devices moving between time zones.
374 if (m->rtc_local_time)
375 tmx.status |= STA_UNSYNC;
379 tmx.status |= STA_INS;
382 tmx.status |= STA_DEL;
386 r = clock_adjtime(CLOCK_REALTIME, &tmx);
390 touch("/var/lib/systemd/clock");
392 m->drift_ppm = tmx.freq / 65536;
394 log_debug(" status : %04i %s\n"
395 " time now : %li.%03llu\n"
397 " offset : %+.3f sec\n"
398 " freq offset : %+li (%i ppm)\n",
399 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
400 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
402 (double)tmx.offset / NSEC_PER_SEC,
403 tmx.freq, m->drift_ppm);
408 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
409 unsigned int i, idx_cur, idx_new, idx_min;
417 /* ignore initial sample */
418 if (m->packet_count == 1)
421 /* store the current data in our samples array */
422 idx_cur = m->samples_idx;
423 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
424 m->samples_idx = idx_new;
425 m->samples[idx_new].offset = offset;
426 m->samples[idx_new].delay = delay;
428 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
429 jitter = m->samples_jitter;
430 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
431 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
435 for (i = 0; i < ELEMENTSOF(m->samples); i++)
436 j += square(m->samples[i].offset - m->samples[idx_min].offset);
437 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
439 /* ignore samples when resyncing */
443 /* always accept offset if we are farther off than the round-trip delay */
444 if (fabs(offset) > delay)
447 /* we need a few samples before looking at them */
448 if (m->packet_count < 4)
451 /* do not accept anything worse than the maximum possible error of the best sample */
452 if (fabs(offset) > m->samples[idx_min].delay)
455 /* compare the difference between the current offset to the previous offset and jitter */
456 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
459 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
462 if (m->poll_resync) {
463 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
464 m->poll_resync = false;
468 /* set to minimal poll interval */
469 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
470 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
474 /* increase polling interval */
475 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
476 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
477 m->poll_interval_usec *= 2;
481 /* decrease polling interval */
482 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
483 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
484 m->poll_interval_usec /= 2;
489 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
490 Manager *m = userdata;
491 struct ntp_msg ntpmsg;
495 .iov_len = sizeof(ntpmsg),
498 struct cmsghdr cmsghdr;
499 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
501 union sockaddr_union server_addr;
502 struct msghdr msghdr = {
505 .msg_control = &control,
506 .msg_controllen = sizeof(control),
507 .msg_name = &server_addr,
508 .msg_namelen = sizeof(server_addr),
510 struct cmsghdr *cmsg;
511 struct timespec *recv_time;
513 double origin, receive, trans, dest;
514 double delay, offset;
515 double root_distance;
523 if (revents & (EPOLLHUP|EPOLLERR)) {
524 log_warning("Server connection returned error.");
525 return manager_connect(m);
528 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
533 log_warning("Error receiving message. Disconnecting.");
534 return manager_connect(m);
537 if (iov.iov_len < sizeof(struct ntp_msg)) {
538 log_warning("Invalid response from server. Disconnecting.");
539 return manager_connect(m);
542 if (!m->current_server_name ||
543 !m->current_server_address ||
544 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
545 log_debug("Response from unknown server.");
550 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
551 if (cmsg->cmsg_level != SOL_SOCKET)
554 switch (cmsg->cmsg_type) {
555 case SCM_TIMESTAMPNS:
556 recv_time = (struct timespec *) CMSG_DATA(cmsg);
561 log_error("Invalid packet timestamp.");
566 log_debug("Unexpected reply. Ignoring.");
570 m->missed_replies = 0;
572 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
573 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
574 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
575 log_debug("Invalid reply; not our transmit time. Ignoring.");
579 m->event_timeout = sd_event_source_unref(m->event_timeout);
581 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
582 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
583 log_debug("Invalid reply, returned times before epoch. Ignoring.");
584 return manager_connect(m);
587 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
588 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
589 log_debug("Server is not synchronized. Disconnecting.");
590 return manager_connect(m);
593 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
594 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
595 return manager_connect(m);
598 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
599 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
600 return manager_connect(m);
603 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
604 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
605 log_debug("Server has too large root distance. Disconnecting.");
606 return manager_connect(m);
611 m->retry_interval = 0;
613 /* announce leap seconds */
614 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
616 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
622 * "Timestamp Name ID When Generated
623 * ------------------------------------------------------------
624 * Originate Timestamp T1 time request sent by client
625 * Receive Timestamp T2 time request received by server
626 * Transmit Timestamp T3 time reply sent by server
627 * Destination Timestamp T4 time reply received by client
629 * The round-trip delay, d, and system clock offset, t, are defined as:
630 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
632 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
633 receive = ntp_ts_to_d(&ntpmsg.recv_time);
634 trans = ntp_ts_to_d(&ntpmsg.trans_time);
635 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
637 offset = ((receive - origin) + (trans - dest)) / 2;
638 delay = (dest - origin) - (trans - receive);
640 spike = manager_sample_spike_detection(m, offset, delay);
642 manager_adjust_poll(m, offset, spike);
644 log_debug("NTP response:\n"
649 " precision : %.6f sec (%d)\n"
650 " root distance: %.6f sec\n"
651 " reference : %.4s\n"
656 " offset : %+.3f sec\n"
657 " delay : %+.3f sec\n"
658 " packet count : %"PRIu64"\n"
660 " poll interval: " USEC_FMT "\n",
661 NTP_FIELD_LEAP(ntpmsg.field),
662 NTP_FIELD_VERSION(ntpmsg.field),
663 NTP_FIELD_MODE(ntpmsg.field),
665 exp2(ntpmsg.precision), ntpmsg.precision,
667 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
668 origin - OFFSET_1900_1970,
669 receive - OFFSET_1900_1970,
670 trans - OFFSET_1900_1970,
671 dest - OFFSET_1900_1970,
674 m->samples_jitter, spike ? " spike" : "",
675 m->poll_interval_usec / USEC_PER_SEC);
679 r = manager_adjust_clock(m, offset, leap_sec);
681 log_error("Failed to call clock_adjtime(): %m");
684 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
685 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
686 spike ? " (ignored)" : "");
688 r = manager_arm_timer(m, m->poll_interval_usec);
690 log_error("Failed to rearm timer: %s", strerror(-r));
697 static int manager_listen_setup(Manager *m) {
698 union sockaddr_union addr = {};
699 static const int tos = IPTOS_LOWDELAY;
700 static const int on = 1;
705 assert(m->server_socket < 0);
706 assert(!m->event_receive);
707 assert(m->current_server_address);
709 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
711 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
712 if (m->server_socket < 0)
715 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
719 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
723 (void) setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
725 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
728 static int manager_begin(Manager *m) {
729 _cleanup_free_ char *pretty = NULL;
733 assert_return(m->current_server_name, -EHOSTUNREACH);
734 assert_return(m->current_server_address, -EHOSTUNREACH);
736 m->missed_replies = NTP_MAX_MISSED_REPLIES;
737 if (m->poll_interval_usec == 0)
738 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
740 server_address_pretty(m->current_server_address, &pretty);
741 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
742 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
744 r = manager_listen_setup(m);
746 log_warning("Failed to setup connection socket: %s", strerror(-r));
750 r = manager_clock_watch_setup(m);
754 return manager_send_request(m);
757 void manager_set_server_name(Manager *m, ServerName *n) {
760 if (m->current_server_name == n)
763 m->current_server_name = n;
764 m->current_server_address = NULL;
766 manager_disconnect(m);
769 log_debug("Selected server %s.", n->string);
772 void manager_set_server_address(Manager *m, ServerAddress *a) {
775 if (m->current_server_address == a)
778 m->current_server_address = a;
779 /* If a is NULL, we are just clearing the address, without
780 * changing the name. Keep the existing name in that case. */
782 m->current_server_name = a->name;
784 manager_disconnect(m);
787 _cleanup_free_ char *pretty = NULL;
788 server_address_pretty(a, &pretty);
789 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
793 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
794 Manager *m = userdata;
799 assert(m->current_server_name);
801 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
804 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
807 return manager_connect(m);
810 for (; ai; ai = ai->ai_next) {
811 _cleanup_free_ char *pretty = NULL;
815 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
817 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
818 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
822 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
824 log_error("Failed to add server address: %s", strerror(-r));
828 server_address_pretty(a, &pretty);
829 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
832 if (!m->current_server_name->addresses) {
833 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
836 return manager_connect(m);
839 manager_set_server_address(m, m->current_server_name->addresses);
841 return manager_begin(m);
844 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
845 Manager *m = userdata;
849 return manager_connect(m);
852 int manager_connect(Manager *m) {
857 manager_disconnect(m);
859 m->event_retry = sd_event_source_unref(m->event_retry);
860 if (!ratelimit_test(&m->ratelimit)) {
861 log_debug("Slowing down attempts to contact servers.");
863 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);
865 log_error("Failed to create retry timer: %s", strerror(-r));
872 /* If we already are operating on some address, switch to the
874 if (m->current_server_address && m->current_server_address->addresses_next)
875 manager_set_server_address(m, m->current_server_address->addresses_next);
877 struct addrinfo hints = {
878 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
879 .ai_socktype = SOCK_DGRAM,
882 /* Hmm, we are through all addresses, let's look for the next host instead */
883 if (m->current_server_name && m->current_server_name->names_next)
884 manager_set_server_name(m, m->current_server_name->names_next);
889 /* Our current server name list is exhausted,
890 * let's find the next one to iterate. First
891 * we try the system list, then the link list.
892 * After having processed the link list we
893 * jump back to the system list. However, if
894 * both lists are empty, we change to the
896 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
897 f = m->system_servers;
903 f = m->system_servers;
909 f = m->fallback_servers;
912 manager_set_server_name(m, NULL);
913 log_debug("No server found.");
917 if (restart && !m->exhausted_servers && m->poll_interval_usec) {
918 log_debug("Waiting after exhausting servers.");
919 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);
921 log_error("Failed to create retry timer: %s", strerror(-r));
925 m->exhausted_servers = true;
927 /* Increase the polling interval */
928 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
929 m->poll_interval_usec *= 2;
934 m->exhausted_servers = false;
936 manager_set_server_name(m, f);
939 /* Tell the resolver to reread /etc/resolv.conf, in
940 * case it changed. */
943 /* Flush out any previously resolved addresses */
944 server_name_flush_addresses(m->current_server_name);
946 log_debug("Resolving %s...", m->current_server_name->string);
948 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
950 log_error("Failed to create resolver: %s", strerror(-r));
957 r = manager_begin(m);
964 void manager_disconnect(Manager *m) {
967 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
969 m->event_timer = sd_event_source_unref(m->event_timer);
971 m->event_receive = sd_event_source_unref(m->event_receive);
972 m->server_socket = safe_close(m->server_socket);
974 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
975 m->clock_watch_fd = safe_close(m->clock_watch_fd);
977 m->event_timeout = sd_event_source_unref(m->event_timeout);
979 sd_notifyf(false, "STATUS=Idle.");
982 void manager_flush_server_names(Manager *m, ServerType t) {
985 if (t == SERVER_SYSTEM)
986 while (m->system_servers)
987 server_name_free(m->system_servers);
989 if (t == SERVER_LINK)
990 while (m->link_servers)
991 server_name_free(m->link_servers);
993 if (t == SERVER_FALLBACK)
994 while (m->fallback_servers)
995 server_name_free(m->fallback_servers);
998 void manager_free(Manager *m) {
1002 manager_disconnect(m);
1003 manager_flush_server_names(m, SERVER_SYSTEM);
1004 manager_flush_server_names(m, SERVER_LINK);
1005 manager_flush_server_names(m, SERVER_FALLBACK);
1007 sd_event_source_unref(m->event_retry);
1009 sd_event_source_unref(m->network_event_source);
1010 sd_network_monitor_unref(m->network_monitor);
1012 sd_resolve_unref(m->resolve);
1013 sd_event_unref(m->event);
1018 static int manager_network_read_link_servers(Manager *m) {
1019 _cleanup_strv_free_ char **ntp = NULL;
1026 r = sd_network_get_ntp(&ntp);
1030 LIST_FOREACH(names, n, m->link_servers)
1033 STRV_FOREACH(i, ntp) {
1036 LIST_FOREACH(names, n, m->link_servers)
1037 if (streq(n->string, *i)) {
1044 r = server_name_new(m, NULL, SERVER_LINK, *i);
1050 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1052 server_name_free(n);
1057 manager_flush_server_names(m, SERVER_LINK);
1061 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1062 Manager *m = userdata;
1063 bool connected, online;
1068 sd_network_monitor_flush(m->network_monitor);
1070 manager_network_read_link_servers(m);
1072 /* check if the machine is online */
1073 online = network_is_online();
1075 /* check if the client is currently connected */
1076 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1078 if (connected && !online) {
1079 log_info("No network connectivity, watching for changes.");
1080 manager_disconnect(m);
1082 } else if (!connected && online) {
1083 log_info("Network configuration changed, trying to establish connection.");
1085 if (m->current_server_address)
1086 r = manager_begin(m);
1088 r = manager_connect(m);
1096 static int manager_network_monitor_listen(Manager *m) {
1101 r = sd_network_monitor_new(&m->network_monitor, NULL);
1105 fd = sd_network_monitor_get_fd(m->network_monitor);
1109 events = sd_network_monitor_get_events(m->network_monitor);
1113 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1120 int manager_new(Manager **ret) {
1121 _cleanup_(manager_freep) Manager *m = NULL;
1126 m = new0(Manager, 1);
1130 m->server_socket = m->clock_watch_fd = -1;
1132 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1134 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1138 r = sd_event_default(&m->event);
1142 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1143 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1145 sd_event_set_watchdog(m->event, true);
1147 r = sd_resolve_default(&m->resolve);
1151 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1155 r = manager_network_monitor_listen(m);
1159 manager_network_read_link_servers(m);