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"
58 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
61 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
64 /* expected accuracy of time synchronization; used to adjust the poll interval */
65 #define NTP_ACCURACY_SEC 0.2
68 * "A client MUST NOT under any conditions use a poll interval less
71 #define NTP_POLL_INTERVAL_MIN_SEC 32
72 #define NTP_POLL_INTERVAL_MAX_SEC 2048
75 * Maximum delta in seconds which the system clock is gradually adjusted
76 * (slew) to approach the network time. Deltas larger that this are set by
77 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
79 #define NTP_MAX_ADJUST 0.4
81 /* NTP protocol, packet header */
82 #define NTP_LEAP_PLUSSEC 1
83 #define NTP_LEAP_MINUSSEC 2
84 #define NTP_LEAP_NOTINSYNC 3
85 #define NTP_MODE_CLIENT 3
86 #define NTP_MODE_SERVER 4
87 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
88 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
89 #define NTP_FIELD_MODE(f) ((f) & 7)
90 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
92 /* Maximum acceptable root distance in seconds. */
93 #define NTP_MAX_ROOT_DISTANCE 5.0
95 /* Maximum number of missed replies before selecting another source. */
96 #define NTP_MAX_MISSED_REPLIES 2
99 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
100 * in seconds relative to 0h on 1 January 1900."
102 #define OFFSET_1900_1970 2208988800UL
104 #define RETRY_USEC (30*USEC_PER_SEC)
105 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
106 #define RATELIMIT_BURST 10
108 #define TIMEOUT_USEC (10*USEC_PER_SEC)
115 struct ntp_ts_short {
125 struct ntp_ts_short root_delay;
126 struct ntp_ts_short root_dispersion;
128 struct ntp_ts reference_time;
129 struct ntp_ts origin_time;
130 struct ntp_ts recv_time;
131 struct ntp_ts trans_time;
134 static int manager_arm_timer(Manager *m, usec_t next);
135 static int manager_clock_watch_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);
189 * Set transmit timestamp, remember it; the server will send that back
190 * as the origin timestamp and we have an indication that this is the
191 * matching answer to our request.
193 * The actual value does not matter, We do not care about the correct
194 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
196 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
197 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
198 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
199 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
201 server_address_pretty(m->current_server_address, &pretty);
203 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
204 if (len == sizeof(ntpmsg)) {
206 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
208 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
209 return manager_connect(m);
212 /* re-arm timer with increasing timeout, in case the packets never arrive back */
213 if (m->retry_interval > 0) {
214 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
215 m->retry_interval *= 2;
217 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
219 r = manager_arm_timer(m, m->retry_interval);
221 log_error("Failed to rearm timer: %s", strerror(-r));
226 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
227 r = sd_event_add_time(
230 clock_boottime_or_monotonic(),
231 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
234 log_error("Failed to arm timeout timer: %s", strerror(-r));
242 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
243 Manager *m = userdata;
247 return manager_send_request(m);
250 static int manager_arm_timer(Manager *m, usec_t next) {
254 assert(m->event_receive);
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 log_error("Failed to create timerfd: %m");
318 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
319 log_error("Failed to set up timerfd: %m");
323 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
325 log_error("Failed to create clock watch event source: %s", strerror(-r));
332 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
333 struct timex tmx = {};
339 * For small deltas, tell the kernel to gradually adjust the system
340 * clock to the NTP time, larger deltas are just directly set.
342 if (fabs(offset) < NTP_MAX_ADJUST) {
343 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
344 tmx.status = STA_PLL;
345 tmx.offset = offset * NSEC_PER_SEC;
346 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
349 log_debug(" adjust (slew): %+.3f sec\n", offset);
351 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
353 /* ADJ_NANO uses nanoseconds in the microseconds field */
354 tmx.time.tv_sec = (long)offset;
355 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
357 /* the kernel expects -0.3s as {-1, 7000.000.000} */
358 if (tmx.time.tv_usec < 0) {
359 tmx.time.tv_sec -= 1;
360 tmx.time.tv_usec += NSEC_PER_SEC;
364 log_debug(" adjust (jump): %+.3f sec\n", offset);
368 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
369 * which syncs the system time periodically to the RTC.
371 * In case the RTC runs in local time, never touch the RTC,
372 * we have no way to properly handle daylight saving changes and
373 * mobile devices moving between time zones.
375 if (m->rtc_local_time)
376 tmx.status |= STA_UNSYNC;
380 tmx.status |= STA_INS;
383 tmx.status |= STA_DEL;
387 r = clock_adjtime(CLOCK_REALTIME, &tmx);
391 touch("/var/lib/systemd/clock");
393 m->drift_ppm = tmx.freq / 65536;
395 log_debug(" status : %04i %s\n"
396 " time now : %li.%03llu\n"
398 " offset : %+.3f sec\n"
399 " freq offset : %+li (%i ppm)\n",
400 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
401 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
403 (double)tmx.offset / NSEC_PER_SEC,
404 tmx.freq, m->drift_ppm);
409 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
410 unsigned int i, idx_cur, idx_new, idx_min;
418 /* ignore initial sample */
419 if (m->packet_count == 1)
422 /* store the current data in our samples array */
423 idx_cur = m->samples_idx;
424 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
425 m->samples_idx = idx_new;
426 m->samples[idx_new].offset = offset;
427 m->samples[idx_new].delay = delay;
429 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
430 jitter = m->samples_jitter;
431 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
432 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
436 for (i = 0; i < ELEMENTSOF(m->samples); i++)
437 j += square(m->samples[i].offset - m->samples[idx_min].offset);
438 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
440 /* ignore samples when resyncing */
444 /* always accept offset if we are farther off than the round-trip delay */
445 if (fabs(offset) > delay)
448 /* we need a few samples before looking at them */
449 if (m->packet_count < 4)
452 /* do not accept anything worse than the maximum possible error of the best sample */
453 if (fabs(offset) > m->samples[idx_min].delay)
456 /* compare the difference between the current offset to the previous offset and jitter */
457 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
460 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
463 if (m->poll_resync) {
464 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
465 m->poll_resync = false;
469 /* set to minimal poll interval */
470 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
471 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
475 /* increase polling interval */
476 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
477 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
478 m->poll_interval_usec *= 2;
482 /* decrease polling interval */
483 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
484 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
485 m->poll_interval_usec /= 2;
490 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
491 Manager *m = userdata;
492 struct ntp_msg ntpmsg;
496 .iov_len = sizeof(ntpmsg),
499 struct cmsghdr cmsghdr;
500 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
502 union sockaddr_union server_addr;
503 struct msghdr msghdr = {
506 .msg_control = &control,
507 .msg_controllen = sizeof(control),
508 .msg_name = &server_addr,
509 .msg_namelen = sizeof(server_addr),
511 struct cmsghdr *cmsg;
512 struct timespec *recv_time;
514 double origin, receive, trans, dest;
515 double delay, offset;
516 double root_distance;
524 if (revents & (EPOLLHUP|EPOLLERR)) {
525 log_warning("Server connection returned error.");
526 return manager_connect(m);
529 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
534 log_warning("Error receiving message. Disconnecting.");
535 return manager_connect(m);
538 if (iov.iov_len < sizeof(struct ntp_msg)) {
539 log_warning("Invalid response from server. Disconnecting.");
540 return manager_connect(m);
543 if (!m->current_server_name ||
544 !m->current_server_address ||
545 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
546 log_debug("Response from unknown server.");
551 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
552 if (cmsg->cmsg_level != SOL_SOCKET)
555 switch (cmsg->cmsg_type) {
556 case SCM_TIMESTAMPNS:
557 recv_time = (struct timespec *) CMSG_DATA(cmsg);
562 log_error("Invalid packet timestamp.");
567 log_debug("Unexpected reply. Ignoring.");
571 m->missed_replies = 0;
573 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
574 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
575 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
576 log_debug("Invalid reply; not our transmit time. Ignoring.");
580 m->event_timeout = sd_event_source_unref(m->event_timeout);
582 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
583 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
584 log_debug("Invalid reply, returned times before epoch. Ignoring.");
585 return manager_connect(m);
588 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
589 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
590 log_debug("Server is not synchronized. Disconnecting.");
591 return manager_connect(m);
594 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
595 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
596 return manager_connect(m);
599 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
600 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
601 return manager_connect(m);
604 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
605 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
606 log_debug("Server has too large root distance. Disconnecting.");
607 return manager_connect(m);
612 m->retry_interval = 0;
614 /* announce leap seconds */
615 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
617 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
623 * "Timestamp Name ID When Generated
624 * ------------------------------------------------------------
625 * Originate Timestamp T1 time request sent by client
626 * Receive Timestamp T2 time request received by server
627 * Transmit Timestamp T3 time reply sent by server
628 * Destination Timestamp T4 time reply received by client
630 * The round-trip delay, d, and system clock offset, t, are defined as:
631 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
633 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
634 receive = ntp_ts_to_d(&ntpmsg.recv_time);
635 trans = ntp_ts_to_d(&ntpmsg.trans_time);
636 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
638 offset = ((receive - origin) + (trans - dest)) / 2;
639 delay = (dest - origin) - (trans - receive);
641 spike = manager_sample_spike_detection(m, offset, delay);
643 manager_adjust_poll(m, offset, spike);
645 log_debug("NTP response:\n"
650 " precision : %.6f sec (%d)\n"
651 " root distance: %.6f sec\n"
652 " reference : %.4s\n"
657 " offset : %+.3f sec\n"
658 " delay : %+.3f sec\n"
659 " packet count : %"PRIu64"\n"
661 " poll interval: " USEC_FMT "\n",
662 NTP_FIELD_LEAP(ntpmsg.field),
663 NTP_FIELD_VERSION(ntpmsg.field),
664 NTP_FIELD_MODE(ntpmsg.field),
666 exp2(ntpmsg.precision), ntpmsg.precision,
668 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
669 origin - OFFSET_1900_1970,
670 receive - OFFSET_1900_1970,
671 trans - OFFSET_1900_1970,
672 dest - OFFSET_1900_1970,
675 m->samples_jitter, spike ? " spike" : "",
676 m->poll_interval_usec / USEC_PER_SEC);
680 r = manager_adjust_clock(m, offset, leap_sec);
682 log_error("Failed to call clock_adjtime(): %m");
685 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
686 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
687 spike ? " (ignored)" : "");
689 r = manager_arm_timer(m, m->poll_interval_usec);
691 log_error("Failed to rearm timer: %s", strerror(-r));
698 static int manager_listen_setup(Manager *m) {
699 union sockaddr_union addr = {};
700 static const int tos = IPTOS_LOWDELAY;
701 static const int on = 1;
706 assert(m->server_socket < 0);
707 assert(!m->event_receive);
708 assert(m->current_server_address);
710 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
712 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
713 if (m->server_socket < 0)
716 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
720 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
724 r = setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
728 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
731 static int manager_begin(Manager *m) {
732 _cleanup_free_ char *pretty = NULL;
736 assert_return(m->current_server_name, -EHOSTUNREACH);
737 assert_return(m->current_server_address, -EHOSTUNREACH);
739 m->missed_replies = NTP_MAX_MISSED_REPLIES;
740 if (m->poll_interval_usec == 0)
741 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
743 server_address_pretty(m->current_server_address, &pretty);
744 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
745 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
747 r = manager_listen_setup(m);
749 log_warning("Failed to setup connection socket: %s", strerror(-r));
753 r = manager_clock_watch_setup(m);
757 return manager_send_request(m);
760 void manager_set_server_name(Manager *m, ServerName *n) {
763 if (m->current_server_name == n)
766 m->current_server_name = n;
767 m->current_server_address = NULL;
769 manager_disconnect(m);
772 log_debug("Selected server %s.", n->string);
775 void manager_set_server_address(Manager *m, ServerAddress *a) {
778 if (m->current_server_address == a)
781 m->current_server_address = a;
782 /* If a is NULL, we are just clearing the address, without
783 * changing the name. Keep the existing name in that case. */
785 m->current_server_name = a->name;
787 manager_disconnect(m);
790 _cleanup_free_ char *pretty = NULL;
791 server_address_pretty(a, &pretty);
792 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
796 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
797 Manager *m = userdata;
802 assert(m->current_server_name);
804 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
807 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
810 return manager_connect(m);
813 for (; ai; ai = ai->ai_next) {
814 _cleanup_free_ char *pretty = NULL;
818 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
820 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
821 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
825 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
827 log_error("Failed to add server address: %s", strerror(-r));
831 server_address_pretty(a, &pretty);
832 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
835 if (!m->current_server_name->addresses) {
836 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
839 return manager_connect(m);
842 manager_set_server_address(m, m->current_server_name->addresses);
844 return manager_begin(m);
847 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
848 Manager *m = userdata;
852 return manager_connect(m);
855 int manager_connect(Manager *m) {
860 manager_disconnect(m);
862 m->event_retry = sd_event_source_unref(m->event_retry);
863 if (!ratelimit_test(&m->ratelimit)) {
864 log_debug("Slowing down attempts to contact servers.");
866 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);
868 log_error("Failed to create retry timer: %s", strerror(-r));
875 /* If we already are operating on some address, switch to the
877 if (m->current_server_address && m->current_server_address->addresses_next)
878 manager_set_server_address(m, m->current_server_address->addresses_next);
880 struct addrinfo hints = {
881 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
882 .ai_socktype = SOCK_DGRAM,
885 /* Hmm, we are through all addresses, let's look for the next host instead */
886 if (m->current_server_name && m->current_server_name->names_next)
887 manager_set_server_name(m, m->current_server_name->names_next);
892 /* Our current server name list is exhausted,
893 * let's find the next one to iterate. First
894 * we try the system list, then the link list.
895 * After having processed the link list we
896 * jump back to the system list. However, if
897 * both lists are empty, we change to the
899 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
900 f = m->system_servers;
906 f = m->system_servers;
912 f = m->fallback_servers;
915 manager_set_server_name(m, NULL);
916 log_debug("No server found.");
920 if (restart && !m->exhausted_servers && m->poll_interval_usec) {
921 log_debug("Waiting after exhausting servers.");
922 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);
924 log_error("Failed to create retry timer: %s", strerror(-r));
928 m->exhausted_servers = true;
930 /* Increase the polling interval */
931 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
932 m->poll_interval_usec *= 2;
937 m->exhausted_servers = false;
939 manager_set_server_name(m, f);
942 /* Tell the resolver to reread /etc/resolv.conf, in
943 * case it changed. */
946 /* Flush out any previously resolved addresses */
947 server_name_flush_addresses(m->current_server_name);
949 log_debug("Resolving %s...", m->current_server_name->string);
951 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
953 log_error("Failed to create resolver: %s", strerror(-r));
960 r = manager_begin(m);
967 void manager_disconnect(Manager *m) {
970 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
972 m->event_timer = sd_event_source_unref(m->event_timer);
974 m->event_receive = sd_event_source_unref(m->event_receive);
975 m->server_socket = safe_close(m->server_socket);
977 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
978 m->clock_watch_fd = safe_close(m->clock_watch_fd);
980 m->event_timeout = sd_event_source_unref(m->event_timeout);
982 sd_notifyf(false, "STATUS=Idle.");
985 void manager_flush_server_names(Manager *m, ServerType t) {
988 if (t == SERVER_SYSTEM)
989 while (m->system_servers)
990 server_name_free(m->system_servers);
992 if (t == SERVER_LINK)
993 while (m->link_servers)
994 server_name_free(m->link_servers);
996 if (t == SERVER_FALLBACK)
997 while (m->fallback_servers)
998 server_name_free(m->fallback_servers);
1001 void manager_free(Manager *m) {
1005 manager_disconnect(m);
1006 manager_flush_server_names(m, SERVER_SYSTEM);
1007 manager_flush_server_names(m, SERVER_LINK);
1008 manager_flush_server_names(m, SERVER_FALLBACK);
1010 sd_event_source_unref(m->event_retry);
1012 sd_event_source_unref(m->network_event_source);
1013 sd_network_monitor_unref(m->network_monitor);
1015 sd_resolve_unref(m->resolve);
1016 sd_event_unref(m->event);
1021 static int manager_network_read_link_servers(Manager *m) {
1022 _cleanup_strv_free_ char **ntp = NULL;
1029 r = sd_network_get_ntp(&ntp);
1033 LIST_FOREACH(names, n, m->link_servers)
1036 STRV_FOREACH(i, ntp) {
1039 LIST_FOREACH(names, n, m->link_servers)
1040 if (streq(n->string, *i)) {
1047 r = server_name_new(m, NULL, SERVER_LINK, *i);
1053 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1055 server_name_free(n);
1060 manager_flush_server_names(m, SERVER_LINK);
1064 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1065 Manager *m = userdata;
1066 bool connected, online;
1071 sd_network_monitor_flush(m->network_monitor);
1073 manager_network_read_link_servers(m);
1075 /* check if the machine is online */
1076 online = network_is_online();
1078 /* check if the client is currently connected */
1079 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1081 if (connected && !online) {
1082 log_info("No network connectivity, watching for changes.");
1083 manager_disconnect(m);
1085 } else if (!connected && online) {
1086 log_info("Network configuration changed, trying to establish connection.");
1088 if (m->current_server_address)
1089 r = manager_begin(m);
1091 r = manager_connect(m);
1099 static int manager_network_monitor_listen(Manager *m) {
1104 r = sd_network_monitor_new(&m->network_monitor, NULL);
1108 fd = sd_network_monitor_get_fd(m->network_monitor);
1112 events = sd_network_monitor_get_events(m->network_monitor);
1116 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1123 int manager_new(Manager **ret) {
1124 _cleanup_(manager_freep) Manager *m = NULL;
1129 m = new0(Manager, 1);
1133 m->server_socket = m->clock_watch_fd = -1;
1135 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1137 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1141 r = sd_event_default(&m->event);
1145 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1146 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1148 sd_event_set_watchdog(m->event, true);
1150 r = sd_resolve_default(&m->resolve);
1154 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1158 r = manager_network_monitor_listen(m);
1162 manager_network_read_link_servers(m);