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);
213 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
214 r = sd_event_add_time(
217 clock_boottime_or_monotonic(),
218 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
221 log_error("Failed to arm timeout timer: %s", strerror(-r));
229 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
230 Manager *m = userdata;
234 return manager_send_request(m);
237 static int manager_arm_timer(Manager *m, usec_t next) {
241 assert(m->event_receive);
244 m->event_timer = sd_event_source_unref(m->event_timer);
248 if (m->event_timer) {
249 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
253 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
256 return sd_event_add_time(
259 clock_boottime_or_monotonic(),
260 now(clock_boottime_or_monotonic()) + next, 0,
264 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
265 Manager *m = userdata;
270 manager_clock_watch_setup(m);
272 /* skip our own jumps */
279 log_info("System time changed. Resyncing.");
280 m->poll_resync = true;
282 return manager_send_request(m);
285 /* wake up when the system time changes underneath us */
286 static int manager_clock_watch_setup(Manager *m) {
288 struct itimerspec its = {
289 .it_value.tv_sec = TIME_T_MAX
296 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
297 safe_close(m->clock_watch_fd);
299 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
300 if (m->clock_watch_fd < 0) {
301 log_error("Failed to create timerfd: %m");
305 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
306 log_error("Failed to set up timerfd: %m");
310 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
312 log_error("Failed to create clock watch event source: %s", strerror(-r));
319 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
320 struct timex tmx = {};
326 * For small deltas, tell the kernel to gradually adjust the system
327 * clock to the NTP time, larger deltas are just directly set.
329 if (fabs(offset) < NTP_MAX_ADJUST) {
330 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
331 tmx.status = STA_PLL;
332 tmx.offset = offset * NSEC_PER_SEC;
333 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
336 log_debug(" adjust (slew): %+.3f sec\n", offset);
338 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
340 /* ADJ_NANO uses nanoseconds in the microseconds field */
341 tmx.time.tv_sec = (long)offset;
342 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
344 /* the kernel expects -0.3s as {-1, 7000.000.000} */
345 if (tmx.time.tv_usec < 0) {
346 tmx.time.tv_sec -= 1;
347 tmx.time.tv_usec += NSEC_PER_SEC;
351 log_debug(" adjust (jump): %+.3f sec\n", offset);
355 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
356 * which syncs the system time periodically to the RTC.
358 * In case the RTC runs in local time, never touch the RTC,
359 * we have no way to properly handle daylight saving changes and
360 * mobile devices moving between time zones.
362 if (m->rtc_local_time)
363 tmx.status |= STA_UNSYNC;
367 tmx.status |= STA_INS;
370 tmx.status |= STA_DEL;
374 r = clock_adjtime(CLOCK_REALTIME, &tmx);
378 touch("/var/lib/systemd/clock");
380 m->drift_ppm = tmx.freq / 65536;
382 log_debug(" status : %04i %s\n"
383 " time now : %li.%03llu\n"
385 " offset : %+.3f sec\n"
386 " freq offset : %+li (%i ppm)\n",
387 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
388 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
390 (double)tmx.offset / NSEC_PER_SEC,
391 tmx.freq, m->drift_ppm);
396 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
397 unsigned int i, idx_cur, idx_new, idx_min;
405 /* ignore initial sample */
406 if (m->packet_count == 1)
409 /* store the current data in our samples array */
410 idx_cur = m->samples_idx;
411 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
412 m->samples_idx = idx_new;
413 m->samples[idx_new].offset = offset;
414 m->samples[idx_new].delay = delay;
416 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
417 jitter = m->samples_jitter;
418 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
419 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
423 for (i = 0; i < ELEMENTSOF(m->samples); i++)
424 j += square(m->samples[i].offset - m->samples[idx_min].offset);
425 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
427 /* ignore samples when resyncing */
431 /* always accept offset if we are farther off than the round-trip delay */
432 if (fabs(offset) > delay)
435 /* we need a few samples before looking at them */
436 if (m->packet_count < 4)
439 /* do not accept anything worse than the maximum possible error of the best sample */
440 if (fabs(offset) > m->samples[idx_min].delay)
443 /* compare the difference between the current offset to the previous offset and jitter */
444 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
447 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
450 if (m->poll_resync) {
451 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
452 m->poll_resync = false;
456 /* set to minimal poll interval */
457 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
458 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
462 /* increase polling interval */
463 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
464 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
465 m->poll_interval_usec *= 2;
469 /* decrease polling interval */
470 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
471 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
472 m->poll_interval_usec /= 2;
477 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
478 Manager *m = userdata;
479 struct ntp_msg ntpmsg;
483 .iov_len = sizeof(ntpmsg),
486 struct cmsghdr cmsghdr;
487 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
489 union sockaddr_union server_addr;
490 struct msghdr msghdr = {
493 .msg_control = &control,
494 .msg_controllen = sizeof(control),
495 .msg_name = &server_addr,
496 .msg_namelen = sizeof(server_addr),
498 struct cmsghdr *cmsg;
499 struct timespec *recv_time;
501 double origin, receive, trans, dest;
502 double delay, offset;
503 double root_distance;
511 if (revents & (EPOLLHUP|EPOLLERR)) {
512 log_warning("Server connection returned error.");
513 return manager_connect(m);
516 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
521 log_warning("Error receiving message. Disconnecting.");
522 return manager_connect(m);
525 if (iov.iov_len < sizeof(struct ntp_msg)) {
526 log_warning("Invalid response from server. Disconnecting.");
527 return manager_connect(m);
530 if (!m->current_server_name ||
531 !m->current_server_address ||
532 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
533 log_debug("Response from unknown server.");
538 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
539 if (cmsg->cmsg_level != SOL_SOCKET)
542 switch (cmsg->cmsg_type) {
543 case SCM_TIMESTAMPNS:
544 recv_time = (struct timespec *) CMSG_DATA(cmsg);
549 log_error("Invalid packet timestamp.");
554 log_debug("Unexpected reply. Ignoring.");
558 m->missed_replies = 0;
560 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
561 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
562 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
563 log_debug("Invalid reply; not our transmit time. Ignoring.");
567 m->event_timeout = sd_event_source_unref(m->event_timeout);
569 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
570 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
571 log_debug("Invalid reply, returned times before epoch. Ignoring.");
572 return manager_connect(m);
575 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
576 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
577 log_debug("Server is not synchronized. Disconnecting.");
578 return manager_connect(m);
581 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
582 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
583 return manager_connect(m);
586 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
587 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
588 return manager_connect(m);
591 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
592 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
593 log_debug("Server has too large root distance. Disconnecting.");
594 return manager_connect(m);
600 /* announce leap seconds */
601 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
603 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
609 * "Timestamp Name ID When Generated
610 * ------------------------------------------------------------
611 * Originate Timestamp T1 time request sent by client
612 * Receive Timestamp T2 time request received by server
613 * Transmit Timestamp T3 time reply sent by server
614 * Destination Timestamp T4 time reply received by client
616 * The round-trip delay, d, and system clock offset, t, are defined as:
617 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
619 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
620 receive = ntp_ts_to_d(&ntpmsg.recv_time);
621 trans = ntp_ts_to_d(&ntpmsg.trans_time);
622 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
624 offset = ((receive - origin) + (trans - dest)) / 2;
625 delay = (dest - origin) - (trans - receive);
627 spike = manager_sample_spike_detection(m, offset, delay);
629 manager_adjust_poll(m, offset, spike);
631 log_debug("NTP response:\n"
636 " precision : %.6f sec (%d)\n"
637 " root distance: %.6f sec\n"
638 " reference : %.4s\n"
643 " offset : %+.3f sec\n"
644 " delay : %+.3f sec\n"
645 " packet count : %"PRIu64"\n"
647 " poll interval: " USEC_FMT "\n",
648 NTP_FIELD_LEAP(ntpmsg.field),
649 NTP_FIELD_VERSION(ntpmsg.field),
650 NTP_FIELD_MODE(ntpmsg.field),
652 exp2(ntpmsg.precision), ntpmsg.precision,
654 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
655 origin - OFFSET_1900_1970,
656 receive - OFFSET_1900_1970,
657 trans - OFFSET_1900_1970,
658 dest - OFFSET_1900_1970,
661 m->samples_jitter, spike ? " spike" : "",
662 m->poll_interval_usec / USEC_PER_SEC);
666 r = manager_adjust_clock(m, offset, leap_sec);
668 log_error("Failed to call clock_adjtime(): %m");
671 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
672 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
673 spike ? " (ignored)" : "");
675 r = manager_arm_timer(m, m->poll_interval_usec);
677 log_error("Failed to rearm timer: %s", strerror(-r));
684 static int manager_listen_setup(Manager *m) {
685 union sockaddr_union addr = {};
686 static const int tos = IPTOS_LOWDELAY;
687 static const int on = 1;
692 assert(m->server_socket < 0);
693 assert(!m->event_receive);
694 assert(m->current_server_address);
696 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
698 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
699 if (m->server_socket < 0)
702 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
706 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
710 setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
712 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
715 static int manager_begin(Manager *m) {
716 _cleanup_free_ char *pretty = NULL;
720 assert_return(m->current_server_name, -EHOSTUNREACH);
721 assert_return(m->current_server_address, -EHOSTUNREACH);
723 m->missed_replies = NTP_MAX_MISSED_REPLIES;
724 if (m->poll_interval_usec == 0)
725 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
727 server_address_pretty(m->current_server_address, &pretty);
728 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
729 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
731 r = manager_listen_setup(m);
733 log_warning("Failed to setup connection socket: %s", strerror(-r));
737 r = manager_clock_watch_setup(m);
741 return manager_send_request(m);
744 void manager_set_server_name(Manager *m, ServerName *n) {
747 if (m->current_server_name == n)
750 m->current_server_name = n;
751 m->current_server_address = NULL;
753 manager_disconnect(m);
756 log_debug("Selected server %s.", n->string);
759 void manager_set_server_address(Manager *m, ServerAddress *a) {
762 if (m->current_server_address == a)
765 m->current_server_address = a;
766 /* If a is NULL, we are just clearing the address, without
767 * changing the name. Keep the existing name in that case. */
769 m->current_server_name = a->name;
771 manager_disconnect(m);
774 _cleanup_free_ char *pretty = NULL;
775 server_address_pretty(a, &pretty);
776 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
780 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
781 Manager *m = userdata;
786 assert(m->current_server_name);
788 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
791 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
794 return manager_connect(m);
797 for (; ai; ai = ai->ai_next) {
798 _cleanup_free_ char *pretty = NULL;
802 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
804 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
805 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
809 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
811 log_error("Failed to add server address: %s", strerror(-r));
815 server_address_pretty(a, &pretty);
816 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
819 if (!m->current_server_name->addresses) {
820 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
823 return manager_connect(m);
826 manager_set_server_address(m, m->current_server_name->addresses);
828 return manager_begin(m);
831 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
832 Manager *m = userdata;
836 return manager_connect(m);
839 int manager_connect(Manager *m) {
844 manager_disconnect(m);
846 m->event_retry = sd_event_source_unref(m->event_retry);
847 if (!ratelimit_test(&m->ratelimit)) {
848 log_debug("Slowing down attempts to contact servers.");
850 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);
852 log_error("Failed to create retry timer: %s", strerror(-r));
859 /* If we already are operating on some address, switch to the
861 if (m->current_server_address && m->current_server_address->addresses_next)
862 manager_set_server_address(m, m->current_server_address->addresses_next);
864 struct addrinfo hints = {
865 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
866 .ai_socktype = SOCK_DGRAM,
869 /* Hmm, we are through all addresses, let's look for the next host instead */
870 if (m->current_server_name && m->current_server_name->names_next)
871 manager_set_server_name(m, m->current_server_name->names_next);
876 /* Our current server name list is exhausted,
877 * let's find the next one to iterate. First
878 * we try the system list, then the link list.
879 * After having processed the link list we
880 * jump back to the system list. However, if
881 * both lists are empty, we change to the
883 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
884 f = m->system_servers;
890 f = m->system_servers;
896 f = m->fallback_servers;
899 manager_set_server_name(m, NULL);
900 log_debug("No server found.");
904 if (restart && !m->exhausted_servers && m->poll_interval_usec) {
905 log_debug("Waiting after exhausting servers.");
906 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);
908 log_error("Failed to create retry timer: %s", strerror(-r));
912 m->exhausted_servers = true;
914 /* Increase the polling interval */
915 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
916 m->poll_interval_usec *= 2;
921 m->exhausted_servers = false;
923 manager_set_server_name(m, f);
926 /* Tell the resolver to reread /etc/resolv.conf, in
927 * case it changed. */
930 /* Flush out any previously resolved addresses */
931 server_name_flush_addresses(m->current_server_name);
933 log_debug("Resolving %s...", m->current_server_name->string);
935 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
937 log_error("Failed to create resolver: %s", strerror(-r));
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 m->event_receive = sd_event_source_unref(m->event_receive);
959 m->server_socket = safe_close(m->server_socket);
961 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
962 m->clock_watch_fd = safe_close(m->clock_watch_fd);
964 m->event_timeout = sd_event_source_unref(m->event_timeout);
966 sd_notifyf(false, "STATUS=Idle.");
969 void manager_flush_server_names(Manager *m, ServerType t) {
972 if (t == SERVER_SYSTEM)
973 while (m->system_servers)
974 server_name_free(m->system_servers);
976 if (t == SERVER_LINK)
977 while (m->link_servers)
978 server_name_free(m->link_servers);
980 if (t == SERVER_FALLBACK)
981 while (m->fallback_servers)
982 server_name_free(m->fallback_servers);
985 void manager_free(Manager *m) {
989 manager_disconnect(m);
990 manager_flush_server_names(m, SERVER_SYSTEM);
991 manager_flush_server_names(m, SERVER_LINK);
992 manager_flush_server_names(m, SERVER_FALLBACK);
994 sd_event_source_unref(m->event_retry);
996 sd_event_source_unref(m->network_event_source);
997 sd_network_monitor_unref(m->network_monitor);
999 sd_resolve_unref(m->resolve);
1000 sd_event_unref(m->event);
1005 static int manager_network_read_link_servers(Manager *m) {
1006 _cleanup_strv_free_ char **ntp = NULL;
1013 r = sd_network_get_ntp(&ntp);
1017 LIST_FOREACH(names, n, m->link_servers)
1020 STRV_FOREACH(i, ntp) {
1023 LIST_FOREACH(names, n, m->link_servers)
1024 if (streq(n->string, *i)) {
1031 r = server_name_new(m, NULL, SERVER_LINK, *i);
1037 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1039 server_name_free(n);
1044 manager_flush_server_names(m, SERVER_LINK);
1048 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1049 Manager *m = userdata;
1050 bool connected, online;
1055 sd_network_monitor_flush(m->network_monitor);
1057 manager_network_read_link_servers(m);
1059 /* check if the machine is online */
1060 online = network_is_online();
1062 /* check if the client is currently connected */
1063 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1065 if (connected && !online) {
1066 log_info("No network connectivity, watching for changes.");
1067 manager_disconnect(m);
1069 } else if (!connected && online) {
1070 log_info("Network configuration changed, trying to establish connection.");
1072 if (m->current_server_address)
1073 r = manager_begin(m);
1075 r = manager_connect(m);
1083 static int manager_network_monitor_listen(Manager *m) {
1088 r = sd_network_monitor_new(&m->network_monitor, NULL);
1092 fd = sd_network_monitor_get_fd(m->network_monitor);
1096 events = sd_network_monitor_get_events(m->network_monitor);
1100 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1107 int manager_new(Manager **ret) {
1108 _cleanup_(manager_freep) Manager *m = NULL;
1113 m = new0(Manager, 1);
1117 m->server_socket = m->clock_watch_fd = -1;
1119 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1121 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1125 r = sd_event_default(&m->event);
1129 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1130 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1132 sd_event_set_watchdog(m->event, true);
1134 r = sd_resolve_default(&m->resolve);
1138 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1142 r = manager_network_monitor_listen(m);
1146 manager_network_read_link_servers(m);