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);
137 static double ntp_ts_short_to_d(const struct ntp_ts_short *ts) {
138 return be16toh(ts->sec) + (be16toh(ts->frac) / 65536.0);
141 static double ntp_ts_to_d(const struct ntp_ts *ts) {
142 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
145 static double ts_to_d(const struct timespec *ts) {
146 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
149 static double square(double d) {
153 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
154 _cleanup_free_ char *pretty = NULL;
155 Manager *m = userdata;
158 assert(m->current_server_name);
159 assert(m->current_server_address);
161 server_address_pretty(m->current_server_address, &pretty);
162 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
164 return manager_connect(m);
167 static int manager_send_request(Manager *m) {
168 _cleanup_free_ char *pretty = NULL;
169 struct ntp_msg ntpmsg = {
171 * "The client initializes the NTP message header, sends the request
172 * to the server, and strips the time of day from the Transmit
173 * Timestamp field of the reply. For this purpose, all the NTP
174 * header fields are set to 0, except the Mode, VN, and optional
175 * Transmit Timestamp fields."
177 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
183 assert(m->current_server_name);
184 assert(m->current_server_address);
186 m->event_timeout = sd_event_source_unref(m->event_timeout);
188 if (m->server_socket < 0) {
189 r = manager_listen_setup(m);
191 return log_warning_errno(r, "Failed to setup connection socket: %m");
195 * Set transmit timestamp, remember it; the server will send that back
196 * as the origin timestamp and we have an indication that this is the
197 * matching answer to our request.
199 * The actual value does not matter, We do not care about the correct
200 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
202 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
203 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
204 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
205 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
207 server_address_pretty(m->current_server_address, &pretty);
209 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
210 if (len == sizeof(ntpmsg)) {
212 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
214 log_debug_errno(errno, "Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
215 return manager_connect(m);
218 /* re-arm timer with increasing timeout, in case the packets never arrive back */
219 if (m->retry_interval > 0) {
220 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
221 m->retry_interval *= 2;
223 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
225 r = manager_arm_timer(m, m->retry_interval);
227 return log_error_errno(r, "Failed to rearm timer: %m");
230 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
231 r = sd_event_add_time(
234 clock_boottime_or_monotonic(),
235 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
238 return log_error_errno(r, "Failed to arm timeout timer: %m");
244 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
245 Manager *m = userdata;
249 return manager_send_request(m);
252 static int manager_arm_timer(Manager *m, usec_t next) {
258 m->event_timer = sd_event_source_unref(m->event_timer);
262 if (m->event_timer) {
263 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
267 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
270 return sd_event_add_time(
273 clock_boottime_or_monotonic(),
274 now(clock_boottime_or_monotonic()) + next, 0,
278 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
279 Manager *m = userdata;
284 manager_clock_watch_setup(m);
286 /* skip our own jumps */
293 log_info("System time changed. Resyncing.");
294 m->poll_resync = true;
296 return manager_send_request(m);
299 /* wake up when the system time changes underneath us */
300 static int manager_clock_watch_setup(Manager *m) {
302 struct itimerspec its = {
303 .it_value.tv_sec = TIME_T_MAX
310 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
311 safe_close(m->clock_watch_fd);
313 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
314 if (m->clock_watch_fd < 0)
315 return log_error_errno(errno, "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 return log_error_errno(errno, "Failed to set up timerfd: %m");
320 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
322 return log_error_errno(r, "Failed to create clock watch event source: %m");
327 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
328 struct timex tmx = {};
334 * For small deltas, tell the kernel to gradually adjust the system
335 * clock to the NTP time, larger deltas are just directly set.
337 if (fabs(offset) < NTP_MAX_ADJUST) {
338 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
339 tmx.status = STA_PLL;
340 tmx.offset = offset * NSEC_PER_SEC;
341 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
344 log_debug(" adjust (slew): %+.3f sec", offset);
346 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
348 /* ADJ_NANO uses nanoseconds in the microseconds field */
349 tmx.time.tv_sec = (long)offset;
350 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
352 /* the kernel expects -0.3s as {-1, 7000.000.000} */
353 if (tmx.time.tv_usec < 0) {
354 tmx.time.tv_sec -= 1;
355 tmx.time.tv_usec += NSEC_PER_SEC;
359 log_debug(" adjust (jump): %+.3f sec", offset);
363 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
364 * which syncs the system time periodically to the RTC.
366 * In case the RTC runs in local time, never touch the RTC,
367 * we have no way to properly handle daylight saving changes and
368 * mobile devices moving between time zones.
370 if (m->rtc_local_time)
371 tmx.status |= STA_UNSYNC;
375 tmx.status |= STA_INS;
378 tmx.status |= STA_DEL;
382 r = clock_adjtime(CLOCK_REALTIME, &tmx);
386 touch("/var/lib/systemd/clock");
388 m->drift_ppm = tmx.freq / 65536;
390 log_debug(" status : %04i %s\n"
391 " time now : %li.%03llu\n"
393 " offset : %+.3f sec\n"
394 " freq offset : %+li (%i ppm)\n",
395 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
396 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
398 (double)tmx.offset / NSEC_PER_SEC,
399 tmx.freq, m->drift_ppm);
404 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
405 unsigned int i, idx_cur, idx_new, idx_min;
413 /* ignore initial sample */
414 if (m->packet_count == 1)
417 /* store the current data in our samples array */
418 idx_cur = m->samples_idx;
419 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
420 m->samples_idx = idx_new;
421 m->samples[idx_new].offset = offset;
422 m->samples[idx_new].delay = delay;
424 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
425 jitter = m->samples_jitter;
426 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
427 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
431 for (i = 0; i < ELEMENTSOF(m->samples); i++)
432 j += square(m->samples[i].offset - m->samples[idx_min].offset);
433 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
435 /* ignore samples when resyncing */
439 /* always accept offset if we are farther off than the round-trip delay */
440 if (fabs(offset) > delay)
443 /* we need a few samples before looking at them */
444 if (m->packet_count < 4)
447 /* do not accept anything worse than the maximum possible error of the best sample */
448 if (fabs(offset) > m->samples[idx_min].delay)
451 /* compare the difference between the current offset to the previous offset and jitter */
452 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
455 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
458 if (m->poll_resync) {
459 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
460 m->poll_resync = false;
464 /* set to minimal poll interval */
465 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
466 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
470 /* increase polling interval */
471 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
472 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
473 m->poll_interval_usec *= 2;
477 /* decrease polling interval */
478 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
479 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
480 m->poll_interval_usec /= 2;
485 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
486 Manager *m = userdata;
487 struct ntp_msg ntpmsg;
491 .iov_len = sizeof(ntpmsg),
494 struct cmsghdr cmsghdr;
495 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
497 union sockaddr_union server_addr;
498 struct msghdr msghdr = {
501 .msg_control = &control,
502 .msg_controllen = sizeof(control),
503 .msg_name = &server_addr,
504 .msg_namelen = sizeof(server_addr),
506 struct cmsghdr *cmsg;
507 struct timespec *recv_time;
509 double origin, receive, trans, dest;
510 double delay, offset;
511 double root_distance;
519 if (revents & (EPOLLHUP|EPOLLERR)) {
520 log_warning("Server connection returned error.");
521 return manager_connect(m);
524 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
529 log_warning("Error receiving message. Disconnecting.");
530 return manager_connect(m);
533 if (iov.iov_len < sizeof(struct ntp_msg)) {
534 log_warning("Invalid response from server. Disconnecting.");
535 return manager_connect(m);
538 if (!m->current_server_name ||
539 !m->current_server_address ||
540 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
541 log_debug("Response from unknown server.");
546 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
547 if (cmsg->cmsg_level != SOL_SOCKET)
550 switch (cmsg->cmsg_type) {
551 case SCM_TIMESTAMPNS:
552 recv_time = (struct timespec *) CMSG_DATA(cmsg);
557 log_error("Invalid packet timestamp.");
562 log_debug("Unexpected reply. Ignoring.");
566 m->missed_replies = 0;
568 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
569 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
570 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
571 log_debug("Invalid reply; not our transmit time. Ignoring.");
575 m->event_timeout = sd_event_source_unref(m->event_timeout);
577 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
578 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
579 log_debug("Invalid reply, returned times before epoch. Ignoring.");
580 return manager_connect(m);
583 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
584 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
585 log_debug("Server is not synchronized. Disconnecting.");
586 return manager_connect(m);
589 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
590 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
591 return manager_connect(m);
594 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
595 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
596 return manager_connect(m);
599 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
600 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
601 log_debug("Server has too large root distance. Disconnecting.");
602 return manager_connect(m);
607 m->retry_interval = 0;
610 m->event_receive = sd_event_source_unref(m->event_receive);
611 m->server_socket = safe_close(m->server_socket);
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_errno(errno, "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 return log_error_errno(r, "Failed to rearm timer: %m");
695 static int manager_listen_setup(Manager *m) {
696 union sockaddr_union addr = {};
697 static const int tos = IPTOS_LOWDELAY;
698 static const int on = 1;
703 assert(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 int manager_begin(Manager *m) {
727 _cleanup_free_ char *pretty = NULL;
731 assert_return(m->current_server_name, -EHOSTUNREACH);
732 assert_return(m->current_server_address, -EHOSTUNREACH);
734 m->missed_replies = NTP_MAX_MISSED_REPLIES;
735 if (m->poll_interval_usec == 0)
736 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
738 server_address_pretty(m->current_server_address, &pretty);
739 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
740 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
742 r = manager_clock_watch_setup(m);
746 return manager_send_request(m);
749 void manager_set_server_name(Manager *m, ServerName *n) {
752 if (m->current_server_name == n)
755 m->current_server_name = n;
756 m->current_server_address = NULL;
758 manager_disconnect(m);
761 log_debug("Selected server %s.", n->string);
764 void manager_set_server_address(Manager *m, ServerAddress *a) {
767 if (m->current_server_address == a)
770 m->current_server_address = a;
771 /* If a is NULL, we are just clearing the address, without
772 * changing the name. Keep the existing name in that case. */
774 m->current_server_name = a->name;
776 manager_disconnect(m);
779 _cleanup_free_ char *pretty = NULL;
780 server_address_pretty(a, &pretty);
781 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
785 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
786 Manager *m = userdata;
791 assert(m->current_server_name);
793 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
796 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
799 return manager_connect(m);
802 for (; ai; ai = ai->ai_next) {
803 _cleanup_free_ char *pretty = NULL;
807 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
809 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
810 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
814 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
816 return log_error_errno(r, "Failed to add server address: %m");
818 server_address_pretty(a, &pretty);
819 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
822 if (!m->current_server_name->addresses) {
823 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
826 return manager_connect(m);
829 manager_set_server_address(m, m->current_server_name->addresses);
831 return manager_begin(m);
834 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
835 Manager *m = userdata;
839 return manager_connect(m);
842 int manager_connect(Manager *m) {
847 manager_disconnect(m);
849 m->event_retry = sd_event_source_unref(m->event_retry);
850 if (!ratelimit_test(&m->ratelimit)) {
851 log_debug("Slowing down attempts to contact servers.");
853 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);
855 return log_error_errno(r, "Failed to create retry timer: %m");
860 /* If we already are operating on some address, switch to the
862 if (m->current_server_address && m->current_server_address->addresses_next)
863 manager_set_server_address(m, m->current_server_address->addresses_next);
865 struct addrinfo hints = {
866 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
867 .ai_socktype = SOCK_DGRAM,
870 /* Hmm, we are through all addresses, let's look for the next host instead */
871 if (m->current_server_name && m->current_server_name->names_next)
872 manager_set_server_name(m, m->current_server_name->names_next);
877 /* Our current server name list is exhausted,
878 * let's find the next one to iterate. First
879 * we try the system list, then the link list.
880 * After having processed the link list we
881 * jump back to the system list. However, if
882 * both lists are empty, we change to the
884 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
885 f = m->system_servers;
891 f = m->system_servers;
897 f = m->fallback_servers;
900 manager_set_server_name(m, NULL);
901 log_debug("No server found.");
905 if (restart && !m->exhausted_servers && m->poll_interval_usec) {
906 log_debug("Waiting after exhausting servers.");
907 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);
909 return log_error_errno(r, "Failed to create retry timer: %m");
911 m->exhausted_servers = true;
913 /* Increase the polling interval */
914 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
915 m->poll_interval_usec *= 2;
920 m->exhausted_servers = false;
922 manager_set_server_name(m, f);
925 /* Tell the resolver to reread /etc/resolv.conf, in
926 * case it changed. */
929 /* Flush out any previously resolved addresses */
930 server_name_flush_addresses(m->current_server_name);
932 log_debug("Resolving %s...", m->current_server_name->string);
934 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
936 return log_error_errno(r, "Failed to create resolver: %m");
941 r = manager_begin(m);
948 void manager_disconnect(Manager *m) {
951 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
953 m->event_timer = sd_event_source_unref(m->event_timer);
955 m->event_receive = sd_event_source_unref(m->event_receive);
956 m->server_socket = safe_close(m->server_socket);
958 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
959 m->clock_watch_fd = safe_close(m->clock_watch_fd);
961 m->event_timeout = sd_event_source_unref(m->event_timeout);
963 sd_notifyf(false, "STATUS=Idle.");
966 void manager_flush_server_names(Manager *m, ServerType t) {
969 if (t == SERVER_SYSTEM)
970 while (m->system_servers)
971 server_name_free(m->system_servers);
973 if (t == SERVER_LINK)
974 while (m->link_servers)
975 server_name_free(m->link_servers);
977 if (t == SERVER_FALLBACK)
978 while (m->fallback_servers)
979 server_name_free(m->fallback_servers);
982 void manager_free(Manager *m) {
986 manager_disconnect(m);
987 manager_flush_server_names(m, SERVER_SYSTEM);
988 manager_flush_server_names(m, SERVER_LINK);
989 manager_flush_server_names(m, SERVER_FALLBACK);
991 sd_event_source_unref(m->event_retry);
993 sd_event_source_unref(m->network_event_source);
994 sd_network_monitor_unref(m->network_monitor);
996 sd_resolve_unref(m->resolve);
997 sd_event_unref(m->event);
1002 static int manager_network_read_link_servers(Manager *m) {
1003 _cleanup_strv_free_ char **ntp = NULL;
1010 r = sd_network_get_ntp(&ntp);
1014 LIST_FOREACH(names, n, m->link_servers)
1017 STRV_FOREACH(i, ntp) {
1020 LIST_FOREACH(names, n, m->link_servers)
1021 if (streq(n->string, *i)) {
1028 r = server_name_new(m, NULL, SERVER_LINK, *i);
1034 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1036 server_name_free(n);
1041 manager_flush_server_names(m, SERVER_LINK);
1045 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1046 Manager *m = userdata;
1047 bool connected, online;
1052 sd_network_monitor_flush(m->network_monitor);
1054 manager_network_read_link_servers(m);
1056 /* check if the machine is online */
1057 online = network_is_online();
1059 /* check if the client is currently connected */
1060 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1062 if (connected && !online) {
1063 log_info("No network connectivity, watching for changes.");
1064 manager_disconnect(m);
1066 } else if (!connected && online) {
1067 log_info("Network configuration changed, trying to establish connection.");
1069 if (m->current_server_address)
1070 r = manager_begin(m);
1072 r = manager_connect(m);
1080 static int manager_network_monitor_listen(Manager *m) {
1085 r = sd_network_monitor_new(&m->network_monitor, NULL);
1089 fd = sd_network_monitor_get_fd(m->network_monitor);
1093 events = sd_network_monitor_get_events(m->network_monitor);
1097 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1104 int manager_new(Manager **ret) {
1105 _cleanup_(manager_freep) Manager *m = NULL;
1110 m = new0(Manager, 1);
1114 m->server_socket = m->clock_watch_fd = -1;
1116 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1118 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1122 r = sd_event_default(&m->event);
1126 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1127 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1129 sd_event_set_watchdog(m->event, true);
1131 r = sd_resolve_default(&m->resolve);
1135 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1139 r = manager_network_monitor_listen(m);
1143 manager_network_read_link_servers(m);