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
96 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
97 * in seconds relative to 0h on 1 January 1900."
99 #define OFFSET_1900_1970 2208988800UL
101 #define RETRY_USEC (30*USEC_PER_SEC)
102 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
103 #define RATELIMIT_BURST 10
105 #define TIMEOUT_USEC (10*USEC_PER_SEC)
112 struct ntp_ts_short {
122 struct ntp_ts_short root_delay;
123 struct ntp_ts_short root_dispersion;
125 struct ntp_ts reference_time;
126 struct ntp_ts origin_time;
127 struct ntp_ts recv_time;
128 struct ntp_ts trans_time;
131 static int manager_arm_timer(Manager *m, usec_t next);
132 static int manager_clock_watch_setup(Manager *m);
134 static double ntp_ts_short_to_d(const struct ntp_ts_short *ts) {
135 return be16toh(ts->sec) + (be16toh(ts->frac) / 65536.0);
138 static double ntp_ts_to_d(const struct ntp_ts *ts) {
139 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
142 static double ts_to_d(const struct timespec *ts) {
143 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
146 static double square(double d) {
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);
186 * Set transmit timestamp, remember it; the server will send that back
187 * as the origin timestamp and we have an indication that this is the
188 * matching answer to our request.
190 * The actual value does not matter, We do not care about the correct
191 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
193 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
194 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
195 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
196 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
198 server_address_pretty(m->current_server_address, &pretty);
200 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
201 if (len == sizeof(ntpmsg)) {
203 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
205 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
206 return manager_connect(m);
209 /* re-arm timer with increasing timeout, in case the packets never arrive back */
210 if (m->retry_interval > 0) {
211 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
212 m->retry_interval *= 2;
214 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
216 r = manager_arm_timer(m, m->retry_interval);
218 log_error("Failed to rearm timer: %s", strerror(-r));
222 r = sd_event_add_time(
225 clock_boottime_or_monotonic(),
226 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
229 log_error("Failed to arm timeout timer: %s", strerror(-r));
236 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
237 Manager *m = userdata;
241 return manager_send_request(m);
244 static int manager_arm_timer(Manager *m, usec_t next) {
248 assert(m->event_receive);
251 m->event_timer = sd_event_source_unref(m->event_timer);
255 if (m->event_timer) {
256 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
260 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
263 return sd_event_add_time(
266 clock_boottime_or_monotonic(),
267 now(clock_boottime_or_monotonic()) + next, 0,
271 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
272 Manager *m = userdata;
277 manager_clock_watch_setup(m);
279 /* skip our own jumps */
286 log_info("System time changed. Resyncing.");
287 m->poll_resync = true;
289 return manager_send_request(m);
292 /* wake up when the system time changes underneath us */
293 static int manager_clock_watch_setup(Manager *m) {
295 struct itimerspec its = {
296 .it_value.tv_sec = TIME_T_MAX
303 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
304 safe_close(m->clock_watch_fd);
306 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
307 if (m->clock_watch_fd < 0) {
308 log_error("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 log_error("Failed to set up timerfd: %m");
317 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
319 log_error("Failed to create clock watch event source: %s", strerror(-r));
326 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
327 struct timex tmx = {};
333 * For small deltas, tell the kernel to gradually adjust the system
334 * clock to the NTP time, larger deltas are just directly set.
336 if (fabs(offset) < NTP_MAX_ADJUST) {
337 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
338 tmx.status = STA_PLL;
339 tmx.offset = offset * NSEC_PER_SEC;
340 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
343 log_debug(" adjust (slew): %+.3f sec\n", offset);
345 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
347 /* ADJ_NANO uses nanoseconds in the microseconds field */
348 tmx.time.tv_sec = (long)offset;
349 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
351 /* the kernel expects -0.3s as {-1, 7000.000.000} */
352 if (tmx.time.tv_usec < 0) {
353 tmx.time.tv_sec -= 1;
354 tmx.time.tv_usec += NSEC_PER_SEC;
358 log_debug(" adjust (jump): %+.3f sec\n", offset);
362 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
363 * which syncs the system time periodically to the RTC.
365 * In case the RTC runs in local time, never touch the RTC,
366 * we have no way to properly handle daylight saving changes and
367 * mobile devices moving between time zones.
369 if (m->rtc_local_time)
370 tmx.status |= STA_UNSYNC;
374 tmx.status |= STA_INS;
377 tmx.status |= STA_DEL;
381 r = clock_adjtime(CLOCK_REALTIME, &tmx);
385 touch("/var/lib/systemd/clock");
387 m->drift_ppm = tmx.freq / 65536;
389 log_debug(" status : %04i %s\n"
390 " time now : %li.%03llu\n"
392 " offset : %+.3f sec\n"
393 " freq offset : %+li (%i ppm)\n",
394 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
395 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
397 (double)tmx.offset / NSEC_PER_SEC,
398 tmx.freq, m->drift_ppm);
403 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
404 unsigned int i, idx_cur, idx_new, idx_min;
412 /* ignore initial sample */
413 if (m->packet_count == 1)
416 /* store the current data in our samples array */
417 idx_cur = m->samples_idx;
418 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
419 m->samples_idx = idx_new;
420 m->samples[idx_new].offset = offset;
421 m->samples[idx_new].delay = delay;
423 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
424 jitter = m->samples_jitter;
425 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
426 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
430 for (i = 0; i < ELEMENTSOF(m->samples); i++)
431 j += square(m->samples[i].offset - m->samples[idx_min].offset);
432 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
434 /* ignore samples when resyncing */
438 /* always accept offset if we are farther off than the round-trip delay */
439 if (fabs(offset) > delay)
442 /* we need a few samples before looking at them */
443 if (m->packet_count < 4)
446 /* do not accept anything worse than the maximum possible error of the best sample */
447 if (fabs(offset) > m->samples[idx_min].delay)
450 /* compare the difference between the current offset to the previous offset and jitter */
451 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
454 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
457 if (m->poll_resync) {
458 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
459 m->poll_resync = false;
463 /* set to minimal poll interval */
464 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
465 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
469 /* increase polling interval */
470 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
471 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
472 m->poll_interval_usec *= 2;
476 /* decrease polling interval */
477 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
478 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
479 m->poll_interval_usec /= 2;
484 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
485 Manager *m = userdata;
486 struct ntp_msg ntpmsg;
490 .iov_len = sizeof(ntpmsg),
493 struct cmsghdr cmsghdr;
494 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
496 union sockaddr_union server_addr;
497 struct msghdr msghdr = {
500 .msg_control = &control,
501 .msg_controllen = sizeof(control),
502 .msg_name = &server_addr,
503 .msg_namelen = sizeof(server_addr),
505 struct cmsghdr *cmsg;
506 struct timespec *recv_time;
508 double origin, receive, trans, dest;
509 double delay, offset;
510 double root_distance;
518 if (revents & (EPOLLHUP|EPOLLERR)) {
519 log_warning("Server connection returned error.");
520 return manager_connect(m);
523 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
528 log_warning("Error receiving message. Disconnecting.");
529 return manager_connect(m);
532 if (iov.iov_len < sizeof(struct ntp_msg)) {
533 log_warning("Invalid response from server. Disconnecting.");
534 return manager_connect(m);
537 if (!m->current_server_name ||
538 !m->current_server_address ||
539 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
540 log_debug("Response from unknown server.");
545 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
546 if (cmsg->cmsg_level != SOL_SOCKET)
549 switch (cmsg->cmsg_type) {
550 case SCM_TIMESTAMPNS:
551 recv_time = (struct timespec *) CMSG_DATA(cmsg);
556 log_error("Invalid packet timestamp.");
561 log_debug("Unexpected reply. Ignoring.");
565 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
566 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
567 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
568 log_debug("Invalid reply; not our transmit time. Ignoring.");
572 m->event_timeout = sd_event_source_unref(m->event_timeout);
574 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
575 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
576 log_debug("Invalid reply, returned times before epoch. Ignoring.");
577 return manager_connect(m);
580 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
581 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
582 log_debug("Server is not synchronized. Disconnecting.");
583 return manager_connect(m);
586 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
587 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
588 return manager_connect(m);
591 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
592 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
593 return manager_connect(m);
596 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
597 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
598 log_debug("Server has too large root distance. Disconnecting.");
599 return manager_connect(m);
604 m->retry_interval = 0;
606 /* announce leap seconds */
607 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
609 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
615 * "Timestamp Name ID When Generated
616 * ------------------------------------------------------------
617 * Originate Timestamp T1 time request sent by client
618 * Receive Timestamp T2 time request received by server
619 * Transmit Timestamp T3 time reply sent by server
620 * Destination Timestamp T4 time reply received by client
622 * The round-trip delay, d, and system clock offset, t, are defined as:
623 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
625 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
626 receive = ntp_ts_to_d(&ntpmsg.recv_time);
627 trans = ntp_ts_to_d(&ntpmsg.trans_time);
628 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
630 offset = ((receive - origin) + (trans - dest)) / 2;
631 delay = (dest - origin) - (trans - receive);
633 spike = manager_sample_spike_detection(m, offset, delay);
635 manager_adjust_poll(m, offset, spike);
637 log_debug("NTP response:\n"
642 " precision : %.6f sec (%d)\n"
643 " root distance: %.6f sec\n"
644 " reference : %.4s\n"
649 " offset : %+.3f sec\n"
650 " delay : %+.3f sec\n"
651 " packet count : %"PRIu64"\n"
653 " poll interval: " USEC_FMT "\n",
654 NTP_FIELD_LEAP(ntpmsg.field),
655 NTP_FIELD_VERSION(ntpmsg.field),
656 NTP_FIELD_MODE(ntpmsg.field),
658 exp2(ntpmsg.precision), ntpmsg.precision,
660 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
661 origin - OFFSET_1900_1970,
662 receive - OFFSET_1900_1970,
663 trans - OFFSET_1900_1970,
664 dest - OFFSET_1900_1970,
667 m->samples_jitter, spike ? " spike" : "",
668 m->poll_interval_usec / USEC_PER_SEC);
672 r = manager_adjust_clock(m, offset, leap_sec);
674 log_error("Failed to call clock_adjtime(): %m");
677 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
678 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
679 spike ? " (ignored)" : "");
681 r = manager_arm_timer(m, m->poll_interval_usec);
683 log_error("Failed to rearm timer: %s", strerror(-r));
690 static int manager_listen_setup(Manager *m) {
691 union sockaddr_union addr = {};
692 static const int tos = IPTOS_LOWDELAY;
693 static const int on = 1;
698 assert(m->server_socket < 0);
699 assert(!m->event_receive);
700 assert(m->current_server_address);
702 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
704 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
705 if (m->server_socket < 0)
708 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
712 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
716 setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
718 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
721 static int manager_begin(Manager *m) {
722 _cleanup_free_ char *pretty = NULL;
726 assert_return(m->current_server_name, -EHOSTUNREACH);
727 assert_return(m->current_server_address, -EHOSTUNREACH);
729 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
731 server_address_pretty(m->current_server_address, &pretty);
732 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
733 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
735 r = manager_listen_setup(m);
737 log_warning("Failed to setup connection socket: %s", strerror(-r));
741 r = manager_clock_watch_setup(m);
745 return manager_send_request(m);
748 void manager_set_server_name(Manager *m, ServerName *n) {
751 if (m->current_server_name == n)
754 m->current_server_name = n;
755 m->current_server_address = NULL;
757 manager_disconnect(m);
760 log_debug("Selected server %s.", n->string);
763 void manager_set_server_address(Manager *m, ServerAddress *a) {
766 if (m->current_server_address == a)
769 m->current_server_address = a;
770 /* If a is NULL, we are just clearing the address, without
771 * changing the name. Keep the existing name in that case. */
773 m->current_server_name = a->name;
775 manager_disconnect(m);
778 _cleanup_free_ char *pretty = NULL;
779 server_address_pretty(a, &pretty);
780 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
784 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
785 Manager *m = userdata;
790 assert(m->current_server_name);
792 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
795 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
798 return manager_connect(m);
801 for (; ai; ai = ai->ai_next) {
802 _cleanup_free_ char *pretty = NULL;
806 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
808 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
809 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
813 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
815 log_error("Failed to add server address: %s", strerror(-r));
819 server_address_pretty(a, &pretty);
820 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
823 if (!m->current_server_name->addresses) {
824 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
827 return manager_connect(m);
830 manager_set_server_address(m, m->current_server_name->addresses);
832 return manager_begin(m);
835 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
836 Manager *m = userdata;
840 return manager_connect(m);
843 int manager_connect(Manager *m) {
848 manager_disconnect(m);
850 m->event_retry = sd_event_source_unref(m->event_retry);
851 if (!ratelimit_test(&m->ratelimit)) {
852 log_debug("Slowing down attempts to contact servers.");
854 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);
856 log_error("Failed to create retry timer: %s", strerror(-r));
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);
879 /* Our current server name list is exhausted,
880 * let's find the next one to iterate. First
881 * we try the system list, then the link list.
882 * After having processed the link list we
883 * jump back to the system list. However, if
884 * both lists are empty, we change to the
886 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
887 f = m->system_servers;
893 f = m->system_servers;
897 f = m->fallback_servers;
900 manager_set_server_name(m, NULL);
901 log_debug("No server found.");
905 manager_set_server_name(m, f);
908 /* Tell the resolver to reread /etc/resolv.conf, in
909 * case it changed. */
912 /* Flush out any previously resolved addresses */
913 server_name_flush_addresses(m->current_server_name);
915 log_debug("Resolving %s...", m->current_server_name->string);
917 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
919 log_error("Failed to create resolver: %s", strerror(-r));
926 r = manager_begin(m);
933 void manager_disconnect(Manager *m) {
936 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
938 m->event_timer = sd_event_source_unref(m->event_timer);
940 m->event_receive = sd_event_source_unref(m->event_receive);
941 m->server_socket = safe_close(m->server_socket);
943 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
944 m->clock_watch_fd = safe_close(m->clock_watch_fd);
946 m->event_timeout = sd_event_source_unref(m->event_timeout);
948 sd_notifyf(false, "STATUS=Idle.");
951 void manager_flush_server_names(Manager *m, ServerType t) {
954 if (t == SERVER_SYSTEM)
955 while (m->system_servers)
956 server_name_free(m->system_servers);
958 if (t == SERVER_LINK)
959 while (m->link_servers)
960 server_name_free(m->link_servers);
962 if (t == SERVER_FALLBACK)
963 while (m->fallback_servers)
964 server_name_free(m->fallback_servers);
967 void manager_free(Manager *m) {
971 manager_disconnect(m);
972 manager_flush_server_names(m, SERVER_SYSTEM);
973 manager_flush_server_names(m, SERVER_LINK);
974 manager_flush_server_names(m, SERVER_FALLBACK);
976 sd_event_source_unref(m->event_retry);
978 sd_event_source_unref(m->network_event_source);
979 sd_network_monitor_unref(m->network_monitor);
981 sd_resolve_unref(m->resolve);
982 sd_event_unref(m->event);
987 static int manager_network_read_link_servers(Manager *m) {
988 _cleanup_strv_free_ char **ntp = NULL;
995 r = sd_network_get_ntp(&ntp);
999 LIST_FOREACH(names, n, m->link_servers)
1002 STRV_FOREACH(i, ntp) {
1005 LIST_FOREACH(names, n, m->link_servers)
1006 if (streq(n->string, *i)) {
1013 r = server_name_new(m, NULL, SERVER_LINK, *i);
1019 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1021 server_name_free(n);
1026 manager_flush_server_names(m, SERVER_LINK);
1030 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1031 Manager *m = userdata;
1032 bool connected, online;
1037 sd_network_monitor_flush(m->network_monitor);
1039 manager_network_read_link_servers(m);
1041 /* check if the machine is online */
1042 online = network_is_online();
1044 /* check if the client is currently connected */
1045 connected = m->server_socket >= 0 || m->resolve_query;
1047 if (connected && !online) {
1048 log_info("No network connectivity, watching for changes.");
1049 manager_disconnect(m);
1051 } else if (!connected && online) {
1052 log_info("Network configuration changed, trying to establish connection.");
1054 if (m->current_server_address)
1055 r = manager_begin(m);
1057 r = manager_connect(m);
1065 static int manager_network_monitor_listen(Manager *m) {
1070 r = sd_network_monitor_new(&m->network_monitor, NULL);
1074 fd = sd_network_monitor_get_fd(m->network_monitor);
1078 events = sd_network_monitor_get_events(m->network_monitor);
1082 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1089 int manager_new(Manager **ret) {
1090 _cleanup_(manager_freep) Manager *m = NULL;
1095 m = new0(Manager, 1);
1099 m->server_socket = m->clock_watch_fd = -1;
1101 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1103 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1107 r = sd_event_default(&m->event);
1111 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1112 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1114 sd_event_set_watchdog(m->event, true);
1116 r = sd_resolve_default(&m->resolve);
1120 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1124 r = manager_network_monitor_listen(m);
1128 manager_network_read_link_servers(m);