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 log_warning_errno(r, "Failed to setup connection socket: %m");
197 * Set transmit timestamp, remember it; the server will send that back
198 * as the origin timestamp and we have an indication that this is the
199 * matching answer to our request.
201 * The actual value does not matter, We do not care about the correct
202 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
204 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
205 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
206 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
207 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
209 server_address_pretty(m->current_server_address, &pretty);
211 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
212 if (len == sizeof(ntpmsg)) {
214 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
216 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
217 return manager_connect(m);
220 /* re-arm timer with increasing timeout, in case the packets never arrive back */
221 if (m->retry_interval > 0) {
222 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
223 m->retry_interval *= 2;
225 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
227 r = manager_arm_timer(m, m->retry_interval);
229 log_error_errno(r, "Failed to rearm timer: %m");
234 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
235 r = sd_event_add_time(
238 clock_boottime_or_monotonic(),
239 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
242 log_error_errno(r, "Failed to arm timeout timer: %m");
250 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
251 Manager *m = userdata;
255 return manager_send_request(m);
258 static int manager_arm_timer(Manager *m, usec_t next) {
264 m->event_timer = sd_event_source_unref(m->event_timer);
268 if (m->event_timer) {
269 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
273 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
276 return sd_event_add_time(
279 clock_boottime_or_monotonic(),
280 now(clock_boottime_or_monotonic()) + next, 0,
284 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
285 Manager *m = userdata;
290 manager_clock_watch_setup(m);
292 /* skip our own jumps */
299 log_info("System time changed. Resyncing.");
300 m->poll_resync = true;
302 return manager_send_request(m);
305 /* wake up when the system time changes underneath us */
306 static int manager_clock_watch_setup(Manager *m) {
308 struct itimerspec its = {
309 .it_value.tv_sec = TIME_T_MAX
316 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
317 safe_close(m->clock_watch_fd);
319 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
320 if (m->clock_watch_fd < 0) {
321 log_error("Failed to create timerfd: %m");
325 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
326 log_error("Failed to set up timerfd: %m");
330 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
332 log_error_errno(r, "Failed to create clock watch event source: %m");
339 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
340 struct timex tmx = {};
346 * For small deltas, tell the kernel to gradually adjust the system
347 * clock to the NTP time, larger deltas are just directly set.
349 if (fabs(offset) < NTP_MAX_ADJUST) {
350 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
351 tmx.status = STA_PLL;
352 tmx.offset = offset * NSEC_PER_SEC;
353 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
356 log_debug(" adjust (slew): %+.3f sec", offset);
358 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
360 /* ADJ_NANO uses nanoseconds in the microseconds field */
361 tmx.time.tv_sec = (long)offset;
362 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
364 /* the kernel expects -0.3s as {-1, 7000.000.000} */
365 if (tmx.time.tv_usec < 0) {
366 tmx.time.tv_sec -= 1;
367 tmx.time.tv_usec += NSEC_PER_SEC;
371 log_debug(" adjust (jump): %+.3f sec", offset);
375 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
376 * which syncs the system time periodically to the RTC.
378 * In case the RTC runs in local time, never touch the RTC,
379 * we have no way to properly handle daylight saving changes and
380 * mobile devices moving between time zones.
382 if (m->rtc_local_time)
383 tmx.status |= STA_UNSYNC;
387 tmx.status |= STA_INS;
390 tmx.status |= STA_DEL;
394 r = clock_adjtime(CLOCK_REALTIME, &tmx);
398 touch("/var/lib/systemd/clock");
400 m->drift_ppm = tmx.freq / 65536;
402 log_debug(" status : %04i %s\n"
403 " time now : %li.%03llu\n"
405 " offset : %+.3f sec\n"
406 " freq offset : %+li (%i ppm)\n",
407 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
408 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
410 (double)tmx.offset / NSEC_PER_SEC,
411 tmx.freq, m->drift_ppm);
416 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
417 unsigned int i, idx_cur, idx_new, idx_min;
425 /* ignore initial sample */
426 if (m->packet_count == 1)
429 /* store the current data in our samples array */
430 idx_cur = m->samples_idx;
431 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
432 m->samples_idx = idx_new;
433 m->samples[idx_new].offset = offset;
434 m->samples[idx_new].delay = delay;
436 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
437 jitter = m->samples_jitter;
438 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
439 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
443 for (i = 0; i < ELEMENTSOF(m->samples); i++)
444 j += square(m->samples[i].offset - m->samples[idx_min].offset);
445 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
447 /* ignore samples when resyncing */
451 /* always accept offset if we are farther off than the round-trip delay */
452 if (fabs(offset) > delay)
455 /* we need a few samples before looking at them */
456 if (m->packet_count < 4)
459 /* do not accept anything worse than the maximum possible error of the best sample */
460 if (fabs(offset) > m->samples[idx_min].delay)
463 /* compare the difference between the current offset to the previous offset and jitter */
464 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
467 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
470 if (m->poll_resync) {
471 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
472 m->poll_resync = false;
476 /* set to minimal poll interval */
477 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
478 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
482 /* increase polling interval */
483 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
484 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
485 m->poll_interval_usec *= 2;
489 /* decrease polling interval */
490 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
491 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
492 m->poll_interval_usec /= 2;
497 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
498 Manager *m = userdata;
499 struct ntp_msg ntpmsg;
503 .iov_len = sizeof(ntpmsg),
506 struct cmsghdr cmsghdr;
507 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
509 union sockaddr_union server_addr;
510 struct msghdr msghdr = {
513 .msg_control = &control,
514 .msg_controllen = sizeof(control),
515 .msg_name = &server_addr,
516 .msg_namelen = sizeof(server_addr),
518 struct cmsghdr *cmsg;
519 struct timespec *recv_time;
521 double origin, receive, trans, dest;
522 double delay, offset;
523 double root_distance;
531 if (revents & (EPOLLHUP|EPOLLERR)) {
532 log_warning("Server connection returned error.");
533 return manager_connect(m);
536 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
541 log_warning("Error receiving message. Disconnecting.");
542 return manager_connect(m);
545 if (iov.iov_len < sizeof(struct ntp_msg)) {
546 log_warning("Invalid response from server. Disconnecting.");
547 return manager_connect(m);
550 if (!m->current_server_name ||
551 !m->current_server_address ||
552 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
553 log_debug("Response from unknown server.");
558 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
559 if (cmsg->cmsg_level != SOL_SOCKET)
562 switch (cmsg->cmsg_type) {
563 case SCM_TIMESTAMPNS:
564 recv_time = (struct timespec *) CMSG_DATA(cmsg);
569 log_error("Invalid packet timestamp.");
574 log_debug("Unexpected reply. Ignoring.");
578 m->missed_replies = 0;
580 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
581 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
582 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
583 log_debug("Invalid reply; not our transmit time. Ignoring.");
587 m->event_timeout = sd_event_source_unref(m->event_timeout);
589 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
590 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
591 log_debug("Invalid reply, returned times before epoch. Ignoring.");
592 return manager_connect(m);
595 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
596 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
597 log_debug("Server is not synchronized. Disconnecting.");
598 return manager_connect(m);
601 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
602 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
603 return manager_connect(m);
606 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
607 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
608 return manager_connect(m);
611 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
612 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
613 log_debug("Server has too large root distance. Disconnecting.");
614 return manager_connect(m);
619 m->retry_interval = 0;
622 m->event_receive = sd_event_source_unref(m->event_receive);
623 m->server_socket = safe_close(m->server_socket);
625 /* announce leap seconds */
626 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
628 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
634 * "Timestamp Name ID When Generated
635 * ------------------------------------------------------------
636 * Originate Timestamp T1 time request sent by client
637 * Receive Timestamp T2 time request received by server
638 * Transmit Timestamp T3 time reply sent by server
639 * Destination Timestamp T4 time reply received by client
641 * The round-trip delay, d, and system clock offset, t, are defined as:
642 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
644 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
645 receive = ntp_ts_to_d(&ntpmsg.recv_time);
646 trans = ntp_ts_to_d(&ntpmsg.trans_time);
647 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
649 offset = ((receive - origin) + (trans - dest)) / 2;
650 delay = (dest - origin) - (trans - receive);
652 spike = manager_sample_spike_detection(m, offset, delay);
654 manager_adjust_poll(m, offset, spike);
656 log_debug("NTP response:\n"
661 " precision : %.6f sec (%d)\n"
662 " root distance: %.6f sec\n"
663 " reference : %.4s\n"
668 " offset : %+.3f sec\n"
669 " delay : %+.3f sec\n"
670 " packet count : %"PRIu64"\n"
672 " poll interval: " USEC_FMT "\n",
673 NTP_FIELD_LEAP(ntpmsg.field),
674 NTP_FIELD_VERSION(ntpmsg.field),
675 NTP_FIELD_MODE(ntpmsg.field),
677 exp2(ntpmsg.precision), ntpmsg.precision,
679 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
680 origin - OFFSET_1900_1970,
681 receive - OFFSET_1900_1970,
682 trans - OFFSET_1900_1970,
683 dest - OFFSET_1900_1970,
686 m->samples_jitter, spike ? " spike" : "",
687 m->poll_interval_usec / USEC_PER_SEC);
691 r = manager_adjust_clock(m, offset, leap_sec);
693 log_error("Failed to call clock_adjtime(): %m");
696 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
697 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
698 spike ? " (ignored)" : "");
700 r = manager_arm_timer(m, m->poll_interval_usec);
702 log_error_errno(r, "Failed to rearm timer: %m");
709 static int manager_listen_setup(Manager *m) {
710 union sockaddr_union addr = {};
711 static const int tos = IPTOS_LOWDELAY;
712 static const int on = 1;
717 assert(m->server_socket < 0);
718 assert(!m->event_receive);
719 assert(m->current_server_address);
721 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
723 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
724 if (m->server_socket < 0)
727 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
731 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
735 (void) setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
737 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
740 static int manager_begin(Manager *m) {
741 _cleanup_free_ char *pretty = NULL;
745 assert_return(m->current_server_name, -EHOSTUNREACH);
746 assert_return(m->current_server_address, -EHOSTUNREACH);
748 m->missed_replies = NTP_MAX_MISSED_REPLIES;
749 if (m->poll_interval_usec == 0)
750 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
752 server_address_pretty(m->current_server_address, &pretty);
753 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
754 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
756 r = manager_clock_watch_setup(m);
760 return manager_send_request(m);
763 void manager_set_server_name(Manager *m, ServerName *n) {
766 if (m->current_server_name == n)
769 m->current_server_name = n;
770 m->current_server_address = NULL;
772 manager_disconnect(m);
775 log_debug("Selected server %s.", n->string);
778 void manager_set_server_address(Manager *m, ServerAddress *a) {
781 if (m->current_server_address == a)
784 m->current_server_address = a;
785 /* If a is NULL, we are just clearing the address, without
786 * changing the name. Keep the existing name in that case. */
788 m->current_server_name = a->name;
790 manager_disconnect(m);
793 _cleanup_free_ char *pretty = NULL;
794 server_address_pretty(a, &pretty);
795 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
799 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
800 Manager *m = userdata;
805 assert(m->current_server_name);
807 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
810 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
813 return manager_connect(m);
816 for (; ai; ai = ai->ai_next) {
817 _cleanup_free_ char *pretty = NULL;
821 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
823 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
824 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
828 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
830 log_error_errno(r, "Failed to add server address: %m");
834 server_address_pretty(a, &pretty);
835 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
838 if (!m->current_server_name->addresses) {
839 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
842 return manager_connect(m);
845 manager_set_server_address(m, m->current_server_name->addresses);
847 return manager_begin(m);
850 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
851 Manager *m = userdata;
855 return manager_connect(m);
858 int manager_connect(Manager *m) {
863 manager_disconnect(m);
865 m->event_retry = sd_event_source_unref(m->event_retry);
866 if (!ratelimit_test(&m->ratelimit)) {
867 log_debug("Slowing down attempts to contact servers.");
869 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);
871 log_error_errno(r, "Failed to create retry timer: %m");
878 /* If we already are operating on some address, switch to the
880 if (m->current_server_address && m->current_server_address->addresses_next)
881 manager_set_server_address(m, m->current_server_address->addresses_next);
883 struct addrinfo hints = {
884 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
885 .ai_socktype = SOCK_DGRAM,
888 /* Hmm, we are through all addresses, let's look for the next host instead */
889 if (m->current_server_name && m->current_server_name->names_next)
890 manager_set_server_name(m, m->current_server_name->names_next);
895 /* Our current server name list is exhausted,
896 * let's find the next one to iterate. First
897 * we try the system list, then the link list.
898 * After having processed the link list we
899 * jump back to the system list. However, if
900 * both lists are empty, we change to the
902 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
903 f = m->system_servers;
909 f = m->system_servers;
915 f = m->fallback_servers;
918 manager_set_server_name(m, NULL);
919 log_debug("No server found.");
923 if (restart && !m->exhausted_servers && m->poll_interval_usec) {
924 log_debug("Waiting after exhausting servers.");
925 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);
927 log_error_errno(r, "Failed to create retry timer: %m");
931 m->exhausted_servers = true;
933 /* Increase the polling interval */
934 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
935 m->poll_interval_usec *= 2;
940 m->exhausted_servers = false;
942 manager_set_server_name(m, f);
945 /* Tell the resolver to reread /etc/resolv.conf, in
946 * case it changed. */
949 /* Flush out any previously resolved addresses */
950 server_name_flush_addresses(m->current_server_name);
952 log_debug("Resolving %s...", m->current_server_name->string);
954 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
956 log_error_errno(r, "Failed to create resolver: %m");
963 r = manager_begin(m);
970 void manager_disconnect(Manager *m) {
973 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
975 m->event_timer = sd_event_source_unref(m->event_timer);
977 m->event_receive = sd_event_source_unref(m->event_receive);
978 m->server_socket = safe_close(m->server_socket);
980 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
981 m->clock_watch_fd = safe_close(m->clock_watch_fd);
983 m->event_timeout = sd_event_source_unref(m->event_timeout);
985 sd_notifyf(false, "STATUS=Idle.");
988 void manager_flush_server_names(Manager *m, ServerType t) {
991 if (t == SERVER_SYSTEM)
992 while (m->system_servers)
993 server_name_free(m->system_servers);
995 if (t == SERVER_LINK)
996 while (m->link_servers)
997 server_name_free(m->link_servers);
999 if (t == SERVER_FALLBACK)
1000 while (m->fallback_servers)
1001 server_name_free(m->fallback_servers);
1004 void manager_free(Manager *m) {
1008 manager_disconnect(m);
1009 manager_flush_server_names(m, SERVER_SYSTEM);
1010 manager_flush_server_names(m, SERVER_LINK);
1011 manager_flush_server_names(m, SERVER_FALLBACK);
1013 sd_event_source_unref(m->event_retry);
1015 sd_event_source_unref(m->network_event_source);
1016 sd_network_monitor_unref(m->network_monitor);
1018 sd_resolve_unref(m->resolve);
1019 sd_event_unref(m->event);
1024 static int manager_network_read_link_servers(Manager *m) {
1025 _cleanup_strv_free_ char **ntp = NULL;
1032 r = sd_network_get_ntp(&ntp);
1036 LIST_FOREACH(names, n, m->link_servers)
1039 STRV_FOREACH(i, ntp) {
1042 LIST_FOREACH(names, n, m->link_servers)
1043 if (streq(n->string, *i)) {
1050 r = server_name_new(m, NULL, SERVER_LINK, *i);
1056 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1058 server_name_free(n);
1063 manager_flush_server_names(m, SERVER_LINK);
1067 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1068 Manager *m = userdata;
1069 bool connected, online;
1074 sd_network_monitor_flush(m->network_monitor);
1076 manager_network_read_link_servers(m);
1078 /* check if the machine is online */
1079 online = network_is_online();
1081 /* check if the client is currently connected */
1082 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1084 if (connected && !online) {
1085 log_info("No network connectivity, watching for changes.");
1086 manager_disconnect(m);
1088 } else if (!connected && online) {
1089 log_info("Network configuration changed, trying to establish connection.");
1091 if (m->current_server_address)
1092 r = manager_begin(m);
1094 r = manager_connect(m);
1102 static int manager_network_monitor_listen(Manager *m) {
1107 r = sd_network_monitor_new(&m->network_monitor, NULL);
1111 fd = sd_network_monitor_get_fd(m->network_monitor);
1115 events = sd_network_monitor_get_events(m->network_monitor);
1119 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1126 int manager_new(Manager **ret) {
1127 _cleanup_(manager_freep) Manager *m = NULL;
1132 m = new0(Manager, 1);
1136 m->server_socket = m->clock_watch_fd = -1;
1138 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1140 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1144 r = sd_event_default(&m->event);
1148 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1149 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1151 sd_event_set_watchdog(m->event, true);
1153 r = sd_resolve_default(&m->resolve);
1157 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1161 r = manager_network_monitor_listen(m);
1165 manager_network_read_link_servers(m);