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 int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
151 _cleanup_free_ char *pretty = NULL;
152 Manager *m = userdata;
155 assert(m->current_server_name);
156 assert(m->current_server_address);
158 server_address_pretty(m->current_server_address, &pretty);
159 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
161 return manager_connect(m);
164 static int manager_send_request(Manager *m) {
165 _cleanup_free_ char *pretty = NULL;
166 struct ntp_msg ntpmsg = {
168 * "The client initializes the NTP message header, sends the request
169 * to the server, and strips the time of day from the Transmit
170 * Timestamp field of the reply. For this purpose, all the NTP
171 * header fields are set to 0, except the Mode, VN, and optional
172 * Transmit Timestamp fields."
174 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
180 assert(m->current_server_name);
181 assert(m->current_server_address);
183 m->event_timeout = sd_event_source_unref(m->event_timeout);
185 r = manager_listen_setup(m);
187 return log_warning_errno(r, "Failed to setup connection socket: %m");
190 * Set transmit timestamp, remember it; the server will send that back
191 * as the origin timestamp and we have an indication that this is the
192 * matching answer to our request.
194 * The actual value does not matter, We do not care about the correct
195 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
197 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
198 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
199 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
200 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
202 server_address_pretty(m->current_server_address, &pretty);
204 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
205 if (len == sizeof(ntpmsg)) {
207 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
209 log_debug_errno(errno, "Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
210 return manager_connect(m);
213 /* re-arm timer with increasing timeout, in case the packets never arrive back */
214 if (m->retry_interval > 0) {
215 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
216 m->retry_interval *= 2;
218 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
220 r = manager_arm_timer(m, m->retry_interval);
222 return log_error_errno(r, "Failed to rearm timer: %m");
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 return log_error_errno(r, "Failed to arm timeout timer: %m");
239 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
240 Manager *m = userdata;
244 return manager_send_request(m);
247 static int manager_arm_timer(Manager *m, usec_t next) {
253 m->event_timer = sd_event_source_unref(m->event_timer);
257 if (m->event_timer) {
258 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
262 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
265 return sd_event_add_time(
268 clock_boottime_or_monotonic(),
269 now(clock_boottime_or_monotonic()) + next, 0,
273 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
274 Manager *m = userdata;
279 manager_clock_watch_setup(m);
281 /* skip our own jumps */
288 log_info("System time changed. Resyncing.");
289 m->poll_resync = true;
291 return manager_send_request(m);
294 /* wake up when the system time changes underneath us */
295 static int manager_clock_watch_setup(Manager *m) {
297 struct itimerspec its = {
298 .it_value.tv_sec = TIME_T_MAX
305 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
306 safe_close(m->clock_watch_fd);
308 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
309 if (m->clock_watch_fd < 0)
310 return log_error_errno(errno, "Failed to create timerfd: %m");
312 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0)
313 return log_error_errno(errno, "Failed to set up timerfd: %m");
315 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
317 return log_error_errno(r, "Failed to create clock watch event source: %m");
322 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
323 struct timex tmx = {};
329 * For small deltas, tell the kernel to gradually adjust the system
330 * clock to the NTP time, larger deltas are just directly set.
332 if (fabs(offset) < NTP_MAX_ADJUST) {
333 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
334 tmx.status = STA_PLL;
335 tmx.offset = offset * NSEC_PER_SEC;
336 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
339 log_debug(" adjust (slew): %+.3f sec", offset);
341 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
343 /* ADJ_NANO uses nanoseconds in the microseconds field */
344 tmx.time.tv_sec = (long)offset;
345 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
347 /* the kernel expects -0.3s as {-1, 7000.000.000} */
348 if (tmx.time.tv_usec < 0) {
349 tmx.time.tv_sec -= 1;
350 tmx.time.tv_usec += NSEC_PER_SEC;
354 log_debug(" adjust (jump): %+.3f sec", offset);
358 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
359 * which syncs the system time periodically to the RTC.
361 * In case the RTC runs in local time, never touch the RTC,
362 * we have no way to properly handle daylight saving changes and
363 * mobile devices moving between time zones.
365 if (m->rtc_local_time)
366 tmx.status |= STA_UNSYNC;
370 tmx.status |= STA_INS;
373 tmx.status |= STA_DEL;
377 r = clock_adjtime(CLOCK_REALTIME, &tmx);
381 touch("/var/lib/systemd/clock");
383 m->drift_ppm = tmx.freq / 65536;
385 log_debug(" status : %04i %s\n"
386 " time now : %li.%03llu\n"
388 " offset : %+.3f sec\n"
389 " freq offset : %+li (%i ppm)\n",
390 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
391 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
393 (double)tmx.offset / NSEC_PER_SEC,
394 tmx.freq, m->drift_ppm);
399 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
400 unsigned int i, idx_cur, idx_new, idx_min;
408 /* ignore initial sample */
409 if (m->packet_count == 1)
412 /* store the current data in our samples array */
413 idx_cur = m->samples_idx;
414 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
415 m->samples_idx = idx_new;
416 m->samples[idx_new].offset = offset;
417 m->samples[idx_new].delay = delay;
419 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
420 jitter = m->samples_jitter;
421 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
422 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
426 for (i = 0; i < ELEMENTSOF(m->samples); i++)
427 j += pow(m->samples[i].offset - m->samples[idx_min].offset, 2);
428 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
430 /* ignore samples when resyncing */
434 /* always accept offset if we are farther off than the round-trip delay */
435 if (fabs(offset) > delay)
438 /* we need a few samples before looking at them */
439 if (m->packet_count < 4)
442 /* do not accept anything worse than the maximum possible error of the best sample */
443 if (fabs(offset) > m->samples[idx_min].delay)
446 /* compare the difference between the current offset to the previous offset and jitter */
447 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
450 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
453 if (m->poll_resync) {
454 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
455 m->poll_resync = false;
459 /* set to minimal poll interval */
460 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
461 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
465 /* increase polling interval */
466 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
467 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
468 m->poll_interval_usec *= 2;
472 /* decrease polling interval */
473 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
474 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
475 m->poll_interval_usec /= 2;
480 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
481 Manager *m = userdata;
482 struct ntp_msg ntpmsg;
486 .iov_len = sizeof(ntpmsg),
489 struct cmsghdr cmsghdr;
490 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
492 union sockaddr_union server_addr;
493 struct msghdr msghdr = {
496 .msg_control = &control,
497 .msg_controllen = sizeof(control),
498 .msg_name = &server_addr,
499 .msg_namelen = sizeof(server_addr),
501 struct cmsghdr *cmsg;
502 struct timespec *recv_time;
504 double origin, receive, trans, dest;
505 double delay, offset;
506 double root_distance;
514 if (revents & (EPOLLHUP|EPOLLERR)) {
515 log_warning("Server connection returned error.");
516 return manager_connect(m);
519 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
524 log_warning("Error receiving message. Disconnecting.");
525 return manager_connect(m);
528 if (iov.iov_len < sizeof(struct ntp_msg)) {
529 log_warning("Invalid response from server. Disconnecting.");
530 return manager_connect(m);
533 if (!m->current_server_name ||
534 !m->current_server_address ||
535 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
536 log_debug("Response from unknown server.");
541 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
542 if (cmsg->cmsg_level != SOL_SOCKET)
545 switch (cmsg->cmsg_type) {
546 case SCM_TIMESTAMPNS:
547 recv_time = (struct timespec *) CMSG_DATA(cmsg);
552 log_error("Invalid packet timestamp.");
557 log_debug("Unexpected reply. Ignoring.");
561 m->missed_replies = 0;
563 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
564 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
565 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
566 log_debug("Invalid reply; not our transmit time. Ignoring.");
570 m->event_timeout = sd_event_source_unref(m->event_timeout);
572 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
573 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
574 log_debug("Invalid reply, returned times before epoch. Ignoring.");
575 return manager_connect(m);
578 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
579 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
580 log_debug("Server is not synchronized. Disconnecting.");
581 return manager_connect(m);
584 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
585 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
586 return manager_connect(m);
589 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
590 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
591 return manager_connect(m);
594 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
595 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
596 log_debug("Server has too large root distance. Disconnecting.");
597 return manager_connect(m);
602 m->retry_interval = 0;
605 manager_listen_stop(m);
607 /* announce leap seconds */
608 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
610 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
616 * "Timestamp Name ID When Generated
617 * ------------------------------------------------------------
618 * Originate Timestamp T1 time request sent by client
619 * Receive Timestamp T2 time request received by server
620 * Transmit Timestamp T3 time reply sent by server
621 * Destination Timestamp T4 time reply received by client
623 * The round-trip delay, d, and system clock offset, t, are defined as:
624 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
626 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
627 receive = ntp_ts_to_d(&ntpmsg.recv_time);
628 trans = ntp_ts_to_d(&ntpmsg.trans_time);
629 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
631 offset = ((receive - origin) + (trans - dest)) / 2;
632 delay = (dest - origin) - (trans - receive);
634 spike = manager_sample_spike_detection(m, offset, delay);
636 manager_adjust_poll(m, offset, spike);
638 log_debug("NTP response:\n"
643 " precision : %.6f sec (%d)\n"
644 " root distance: %.6f sec\n"
645 " reference : %.4s\n"
650 " offset : %+.3f sec\n"
651 " delay : %+.3f sec\n"
652 " packet count : %"PRIu64"\n"
654 " poll interval: " USEC_FMT "\n",
655 NTP_FIELD_LEAP(ntpmsg.field),
656 NTP_FIELD_VERSION(ntpmsg.field),
657 NTP_FIELD_MODE(ntpmsg.field),
659 exp2(ntpmsg.precision), ntpmsg.precision,
661 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
662 origin - OFFSET_1900_1970,
663 receive - OFFSET_1900_1970,
664 trans - OFFSET_1900_1970,
665 dest - OFFSET_1900_1970,
668 m->samples_jitter, spike ? " spike" : "",
669 m->poll_interval_usec / USEC_PER_SEC);
673 r = manager_adjust_clock(m, offset, leap_sec);
675 log_error_errno(errno, "Failed to call clock_adjtime(): %m");
678 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
679 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
680 spike ? " (ignored)" : "");
682 r = manager_arm_timer(m, m->poll_interval_usec);
684 return log_error_errno(r, "Failed to rearm timer: %m");
689 static int manager_listen_setup(Manager *m) {
690 union sockaddr_union addr = {};
691 static const int tos = IPTOS_LOWDELAY;
692 static const int on = 1;
697 if (m->server_socket >= 0)
700 assert(!m->event_receive);
701 assert(m->current_server_address);
703 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
705 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
706 if (m->server_socket < 0)
709 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
713 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
717 (void) setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
719 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
722 static void manager_listen_stop(Manager *m) {
725 m->event_receive = sd_event_source_unref(m->event_receive);
726 m->server_socket = safe_close(m->server_socket);
729 static int manager_begin(Manager *m) {
730 _cleanup_free_ char *pretty = NULL;
734 assert_return(m->current_server_name, -EHOSTUNREACH);
735 assert_return(m->current_server_address, -EHOSTUNREACH);
737 m->missed_replies = NTP_MAX_MISSED_REPLIES;
738 if (m->poll_interval_usec == 0)
739 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
741 server_address_pretty(m->current_server_address, &pretty);
742 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
743 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
745 r = manager_clock_watch_setup(m);
749 return manager_send_request(m);
752 void manager_set_server_name(Manager *m, ServerName *n) {
755 if (m->current_server_name == n)
758 m->current_server_name = n;
759 m->current_server_address = NULL;
761 manager_disconnect(m);
764 log_debug("Selected server %s.", n->string);
767 void manager_set_server_address(Manager *m, ServerAddress *a) {
770 if (m->current_server_address == a)
773 m->current_server_address = a;
774 /* If a is NULL, we are just clearing the address, without
775 * changing the name. Keep the existing name in that case. */
777 m->current_server_name = a->name;
779 manager_disconnect(m);
782 _cleanup_free_ char *pretty = NULL;
783 server_address_pretty(a, &pretty);
784 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
788 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
789 Manager *m = userdata;
794 assert(m->current_server_name);
796 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
799 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
802 return manager_connect(m);
805 for (; ai; ai = ai->ai_next) {
806 _cleanup_free_ char *pretty = NULL;
810 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
812 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
813 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
817 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
819 return log_error_errno(r, "Failed to add server address: %m");
821 server_address_pretty(a, &pretty);
822 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
825 if (!m->current_server_name->addresses) {
826 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
829 return manager_connect(m);
832 manager_set_server_address(m, m->current_server_name->addresses);
834 return manager_begin(m);
837 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
838 Manager *m = userdata;
842 return manager_connect(m);
845 int manager_connect(Manager *m) {
850 manager_disconnect(m);
852 m->event_retry = sd_event_source_unref(m->event_retry);
853 if (!ratelimit_test(&m->ratelimit)) {
854 log_debug("Slowing down attempts to contact servers.");
856 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);
858 return log_error_errno(r, "Failed to create retry timer: %m");
863 /* If we already are operating on some address, switch to the
865 if (m->current_server_address && m->current_server_address->addresses_next)
866 manager_set_server_address(m, m->current_server_address->addresses_next);
868 struct addrinfo hints = {
869 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
870 .ai_socktype = SOCK_DGRAM,
873 /* Hmm, we are through all addresses, let's look for the next host instead */
874 if (m->current_server_name && m->current_server_name->names_next)
875 manager_set_server_name(m, m->current_server_name->names_next);
880 /* Our current server name list is exhausted,
881 * let's find the next one to iterate. First
882 * we try the system list, then the link list.
883 * After having processed the link list we
884 * jump back to the system list. However, if
885 * both lists are empty, we change to the
887 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
888 f = m->system_servers;
894 f = m->system_servers;
900 f = m->fallback_servers;
903 manager_set_server_name(m, NULL);
904 log_debug("No server found.");
908 if (restart && !m->exhausted_servers && m->poll_interval_usec) {
909 log_debug("Waiting after exhausting servers.");
910 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);
912 return log_error_errno(r, "Failed to create retry timer: %m");
914 m->exhausted_servers = true;
916 /* Increase the polling interval */
917 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
918 m->poll_interval_usec *= 2;
923 m->exhausted_servers = false;
925 manager_set_server_name(m, f);
928 /* Tell the resolver to reread /etc/resolv.conf, in
929 * case it changed. */
932 /* Flush out any previously resolved addresses */
933 server_name_flush_addresses(m->current_server_name);
935 log_debug("Resolving %s...", m->current_server_name->string);
937 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
939 return log_error_errno(r, "Failed to create resolver: %m");
944 r = manager_begin(m);
951 void manager_disconnect(Manager *m) {
954 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
956 m->event_timer = sd_event_source_unref(m->event_timer);
958 manager_listen_stop(m);
960 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
961 m->clock_watch_fd = safe_close(m->clock_watch_fd);
963 m->event_timeout = sd_event_source_unref(m->event_timeout);
965 sd_notifyf(false, "STATUS=Idle.");
968 void manager_flush_server_names(Manager *m, ServerType t) {
971 if (t == SERVER_SYSTEM)
972 while (m->system_servers)
973 server_name_free(m->system_servers);
975 if (t == SERVER_LINK)
976 while (m->link_servers)
977 server_name_free(m->link_servers);
979 if (t == SERVER_FALLBACK)
980 while (m->fallback_servers)
981 server_name_free(m->fallback_servers);
984 void manager_free(Manager *m) {
988 manager_disconnect(m);
989 manager_flush_server_names(m, SERVER_SYSTEM);
990 manager_flush_server_names(m, SERVER_LINK);
991 manager_flush_server_names(m, SERVER_FALLBACK);
993 sd_event_source_unref(m->event_retry);
995 sd_event_source_unref(m->network_event_source);
996 sd_network_monitor_unref(m->network_monitor);
998 sd_resolve_unref(m->resolve);
999 sd_event_unref(m->event);
1004 static int manager_network_read_link_servers(Manager *m) {
1005 _cleanup_strv_free_ char **ntp = NULL;
1012 r = sd_network_get_ntp(&ntp);
1016 LIST_FOREACH(names, n, m->link_servers)
1019 STRV_FOREACH(i, ntp) {
1022 LIST_FOREACH(names, n, m->link_servers)
1023 if (streq(n->string, *i)) {
1030 r = server_name_new(m, NULL, SERVER_LINK, *i);
1036 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1038 server_name_free(n);
1043 manager_flush_server_names(m, SERVER_LINK);
1047 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1048 Manager *m = userdata;
1049 bool connected, online;
1054 sd_network_monitor_flush(m->network_monitor);
1056 manager_network_read_link_servers(m);
1058 /* check if the machine is online */
1059 online = network_is_online();
1061 /* check if the client is currently connected */
1062 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1064 if (connected && !online) {
1065 log_info("No network connectivity, watching for changes.");
1066 manager_disconnect(m);
1068 } else if (!connected && online) {
1069 log_info("Network configuration changed, trying to establish connection.");
1071 if (m->current_server_address)
1072 r = manager_begin(m);
1074 r = manager_connect(m);
1082 static int manager_network_monitor_listen(Manager *m) {
1087 r = sd_network_monitor_new(&m->network_monitor, NULL);
1091 fd = sd_network_monitor_get_fd(m->network_monitor);
1095 events = sd_network_monitor_get_events(m->network_monitor);
1099 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1106 int manager_new(Manager **ret) {
1107 _cleanup_(manager_freep) Manager *m = NULL;
1112 m = new0(Manager, 1);
1116 m->server_socket = m->clock_watch_fd = -1;
1118 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1120 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1124 r = sd_event_default(&m->event);
1128 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1129 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1131 sd_event_set_watchdog(m->event, true);
1133 r = sd_resolve_default(&m->resolve);
1137 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1141 r = manager_network_monitor_listen(m);
1145 manager_network_read_link_servers(m);