1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
4 This file is part of systemd.
6 Copyright 2014 Kay Sievers
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>
39 #include "sparse-endian.h"
41 #include "socket-util.h"
43 #include "ratelimit.h"
46 #include "sd-resolve.h"
47 #include "sd-daemon.h"
49 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
52 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
55 /* expected accuracy of time synchronization; used to adjust the poll interval */
56 #define NTP_ACCURACY_SEC 0.2
59 * "A client MUST NOT under any conditions use a poll interval less
62 #define NTP_POLL_INTERVAL_MIN_SEC 32
63 #define NTP_POLL_INTERVAL_MAX_SEC 2048
66 * Maximum delta in seconds which the system clock is gradually adjusted
67 * (slew) to approach the network time. Deltas larger that this are set by
68 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
70 #define NTP_MAX_ADJUST 0.4
72 /* NTP protocol, packet header */
73 #define NTP_LEAP_PLUSSEC 1
74 #define NTP_LEAP_MINUSSEC 2
75 #define NTP_LEAP_NOTINSYNC 3
76 #define NTP_MODE_CLIENT 3
77 #define NTP_MODE_SERVER 4
78 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
79 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
80 #define NTP_FIELD_MODE(f) ((f) & 7)
81 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
84 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
85 * in seconds relative to 0h on 1 January 1900."
87 #define OFFSET_1900_1970 2208988800UL
89 #define RETRY_USEC (30*USEC_PER_SEC)
90 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
91 #define RATELIMIT_BURST 10
93 #define TIMEOUT_USEC (10*USEC_PER_SEC)
100 struct ntp_ts_short {
110 struct ntp_ts_short root_delay;
111 struct ntp_ts_short root_dispersion;
113 struct ntp_ts reference_time;
114 struct ntp_ts origin_time;
115 struct ntp_ts recv_time;
116 struct ntp_ts trans_time;
119 typedef struct Manager Manager;
120 typedef struct ServerAddress ServerAddress;
121 typedef struct ServerName ServerName;
123 struct ServerAddress {
124 union sockaddr_union sockaddr;
126 LIST_FIELDS(ServerAddress, addresses);
131 LIST_HEAD(ServerAddress, addresses);
132 LIST_FIELDS(ServerName, names);
139 LIST_HEAD(ServerName, servers);
144 sd_resolve_query *resolve_query;
145 sd_event_source *event_receive;
146 ServerName *current_server_name;
147 ServerAddress *current_server_address;
149 uint64_t packet_count;
150 sd_event_source *event_timeout;
152 /* last sent packet */
153 struct timespec trans_time_mon;
154 struct timespec trans_time;
155 usec_t retry_interval;
159 sd_event_source *event_timer;
160 usec_t poll_interval_usec;
168 unsigned int samples_idx;
169 double samples_jitter;
175 /* watch for time changes */
176 sd_event_source *event_clock_watch;
179 /* Retry connections */
180 sd_event_source *event_retry;
182 /* Handle SIGINT/SIGTERM */
183 sd_event_source *sigterm, *sigint;
186 static void manager_free(Manager *m);
187 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
188 #define _cleanup_manager_free_ _cleanup_(manager_freep)
190 static int manager_arm_timer(Manager *m, usec_t next);
191 static int manager_clock_watch_setup(Manager *m);
192 static int manager_connect(Manager *m);
193 static void manager_disconnect(Manager *m);
195 static double ntp_ts_to_d(const struct ntp_ts *ts) {
196 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
199 static double ts_to_d(const struct timespec *ts) {
200 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
203 static double tv_to_d(const struct timeval *tv) {
204 return tv->tv_sec + (1.0e-6 * tv->tv_usec);
207 static double square(double d) {
211 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
212 _cleanup_free_ char *pretty = NULL;
213 Manager *m = userdata;
216 assert(m->current_server_name);
217 assert(m->current_server_address);
219 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
220 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
222 return manager_connect(m);
225 static int manager_send_request(Manager *m) {
226 _cleanup_free_ char *pretty = NULL;
227 struct ntp_msg ntpmsg = {
229 * "The client initializes the NTP message header, sends the request
230 * to the server, and strips the time of day from the Transmit
231 * Timestamp field of the reply. For this purpose, all the NTP
232 * header fields are set to 0, except the Mode, VN, and optional
233 * Transmit Timestamp fields."
235 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
241 assert(m->current_server_name);
242 assert(m->current_server_address);
244 m->event_timeout = sd_event_source_unref(m->event_timeout);
247 * Set transmit timestamp, remember it; the server will send that back
248 * as the origin timestamp and we have an indication that this is the
249 * matching answer to our request.
251 * The actual value does not matter, We do not care about the correct
252 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
254 assert_se(clock_gettime(CLOCK_MONOTONIC, &m->trans_time_mon) >= 0);
255 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
256 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
257 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
259 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
261 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
262 if (len == sizeof(ntpmsg)) {
264 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
266 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
267 return manager_connect(m);
270 /* re-arm timer with incresing timeout, in case the packets never arrive back */
271 if (m->retry_interval > 0) {
272 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
273 m->retry_interval *= 2;
275 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
277 r = manager_arm_timer(m, m->retry_interval);
279 log_error("Failed to rearm timer: %s", strerror(-r));
283 r = sd_event_add_time(
287 now(CLOCK_MONOTONIC) + TIMEOUT_USEC, 0,
290 log_error("Failed to arm timeout timer: %s", strerror(-r));
297 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
298 Manager *m = userdata;
302 return manager_send_request(m);
305 static int manager_arm_timer(Manager *m, usec_t next) {
309 assert(m->event_receive);
312 m->event_timer = sd_event_source_unref(m->event_timer);
316 if (m->event_timer) {
317 r = sd_event_source_set_time(m->event_timer, now(CLOCK_MONOTONIC) + next);
321 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
324 return sd_event_add_time(
328 now(CLOCK_MONOTONIC) + next, 0,
332 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
333 Manager *m = userdata;
338 manager_clock_watch_setup(m);
340 /* skip our own jumps */
347 log_info("System time changed. Resyncing.");
348 m->poll_resync = true;
349 return manager_send_request(m);
352 /* wake up when the system time changes underneath us */
353 static int manager_clock_watch_setup(Manager *m) {
355 struct itimerspec its = {
356 .it_value.tv_sec = TIME_T_MAX
363 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
364 safe_close(m->clock_watch_fd);
366 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
367 if (m->clock_watch_fd < 0) {
368 log_error("Failed to create timerfd: %m");
372 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
373 log_error("Failed to set up timerfd: %m");
377 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
379 log_error("Failed to create clock watch event source: %s", strerror(-r));
386 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
387 struct timex tmx = {};
393 * For small deltas, tell the kernel to gradually adjust the system
394 * clock to the NTP time, larger deltas are just directly set.
396 * Clear STA_UNSYNC, it will enable the kernel's 11-minute mode, which
397 * syncs the system time periodically to the hardware clock.
399 if (fabs(offset) < NTP_MAX_ADJUST) {
400 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
401 tmx.status = STA_PLL;
402 tmx.offset = offset * NSEC_PER_SEC;
403 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
406 log_debug(" adjust (slew): %+.3f sec\n", offset);
408 tmx.modes = ADJ_SETOFFSET | ADJ_NANO;
410 /* ADJ_NANO uses nanoseconds in the microseconds field */
411 tmx.time.tv_sec = (long)offset;
412 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
414 /* the kernel expects -0.3s as {-1, 7000.000.000} */
415 if (tmx.time.tv_usec < 0) {
416 tmx.time.tv_sec -= 1;
417 tmx.time.tv_usec += NSEC_PER_SEC;
421 log_debug(" adjust (jump): %+.3f sec\n", offset);
426 tmx.status |= STA_INS;
429 tmx.status |= STA_DEL;
433 r = clock_adjtime(CLOCK_REALTIME, &tmx);
437 m->drift_ppm = tmx.freq / 65536;
439 log_debug(" status : %04i %s\n"
440 " time now : %li.%03lli\n"
442 " offset : %+.3f sec\n"
443 " freq offset : %+li (%i ppm)\n",
444 tmx.status, tmx.status & STA_UNSYNC ? "" : "sync",
445 tmx.time.tv_sec, tmx.time.tv_usec / NSEC_PER_MSEC,
447 (double)tmx.offset / NSEC_PER_SEC,
448 tmx.freq, m->drift_ppm);
453 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
454 unsigned int i, idx_cur, idx_new, idx_min;
462 /* ignore initial sample */
463 if (m->packet_count == 1)
466 /* store the current data in our samples array */
467 idx_cur = m->samples_idx;
468 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
469 m->samples_idx = idx_new;
470 m->samples[idx_new].offset = offset;
471 m->samples[idx_new].delay = delay;
473 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
474 jitter = m->samples_jitter;
475 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
476 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
480 for (i = 0; i < ELEMENTSOF(m->samples); i++)
481 j += square(m->samples[i].offset - m->samples[idx_min].offset);
482 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
484 /* ignore samples when resyncing */
488 /* always accept offset if we are farther off than the round-trip delay */
489 if (fabs(offset) > delay)
492 /* we need a few samples before looking at them */
493 if (m->packet_count < 4)
496 /* do not accept anything worse than the maximum possible error of the best sample */
497 if (fabs(offset) > m->samples[idx_min].delay)
500 /* compare the difference between the current offset to the previous offset and jitter */
501 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
504 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
507 if (m->poll_resync) {
508 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
509 m->poll_resync = false;
513 /* set to minimal poll interval */
514 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
515 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
519 /* increase polling interval */
520 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
521 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
522 m->poll_interval_usec *= 2;
526 /* decrease polling interval */
527 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
528 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
529 m->poll_interval_usec /= 2;
534 static bool sockaddr_equal(union sockaddr_union *a, union sockaddr_union *b) {
538 if (a->sa.sa_family != b->sa.sa_family)
541 if (a->sa.sa_family == AF_INET)
542 return a->in.sin_addr.s_addr == b->in.sin_addr.s_addr;
544 if (a->sa.sa_family == AF_INET6)
545 return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)) == 0;
550 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
551 _cleanup_free_ char *pretty = NULL;
552 Manager *m = userdata;
553 struct ntp_msg ntpmsg;
557 .iov_len = sizeof(ntpmsg),
560 struct cmsghdr cmsghdr;
561 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
563 union sockaddr_union server_addr;
564 struct msghdr msghdr = {
567 .msg_control = &control,
568 .msg_controllen = sizeof(control),
569 .msg_name = &server_addr,
570 .msg_namelen = sizeof(server_addr),
572 struct cmsghdr *cmsg;
573 struct timespec now_ts;
574 struct timeval *recv_time;
576 double origin, receive, trans, dest;
577 double delay, offset;
585 if (revents & (EPOLLHUP|EPOLLERR)) {
586 log_warning("Server connection returned error.");
587 return manager_connect(m);
590 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
595 log_warning("Error receiving message. Disconnecting.");
596 return manager_connect(m);
599 if (iov.iov_len < sizeof(struct ntp_msg)) {
600 log_warning("Invalid response from server. Disconnecting.");
601 return manager_connect(m);
604 if (!m->current_server_name ||
605 !m->current_server_address ||
606 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
607 log_debug("Response from unknown server.");
612 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
613 if (cmsg->cmsg_level != SOL_SOCKET)
616 switch (cmsg->cmsg_type) {
618 recv_time = (struct timeval *) CMSG_DATA(cmsg);
623 log_error("Invalid packet timestamp.");
628 log_debug("Unexpected reply. Ignoring.");
632 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
633 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
634 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
635 log_debug("Invalid reply; not our transmit time. Ignoring.");
639 m->event_timeout = sd_event_source_unref(m->event_timeout);
641 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC) {
642 log_debug("Server is not synchronized. Disconnecting.");
643 return manager_connect(m);
646 if (NTP_FIELD_VERSION(ntpmsg.field) != 4 && NTP_FIELD_VERSION(ntpmsg.field) != 3) {
647 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
648 return manager_connect(m);
651 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
652 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
653 return manager_connect(m);
658 m->retry_interval = 0;
660 /* announce leap seconds */
661 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
663 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
669 * "Timestamp Name ID When Generated
670 * ------------------------------------------------------------
671 * Originate Timestamp T1 time request sent by client
672 * Receive Timestamp T2 time request received by server
673 * Transmit Timestamp T3 time reply sent by server
674 * Destination Timestamp T4 time reply received by client
676 * The round-trip delay, d, and system clock offset, t, are defined as:
677 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
679 assert_se(clock_gettime(CLOCK_MONOTONIC, &now_ts) >= 0);
680 origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&m->trans_time_mon)) + OFFSET_1900_1970;
681 receive = ntp_ts_to_d(&ntpmsg.recv_time);
682 trans = ntp_ts_to_d(&ntpmsg.trans_time);
683 dest = tv_to_d(recv_time) + OFFSET_1900_1970;
685 offset = ((receive - origin) + (trans - dest)) / 2;
686 delay = (dest - origin) - (trans - receive);
688 spike = manager_sample_spike_detection(m, offset, delay);
690 manager_adjust_poll(m, offset, spike);
692 log_debug("NTP response:\n"
697 " precision : %.6f sec (%d)\n"
698 " reference : %.4s\n"
703 " offset : %+.3f sec\n"
704 " delay : %+.3f sec\n"
705 " packet count : %"PRIu64"\n"
707 " poll interval: %llu\n",
708 NTP_FIELD_LEAP(ntpmsg.field),
709 NTP_FIELD_VERSION(ntpmsg.field),
710 NTP_FIELD_MODE(ntpmsg.field),
712 exp2(ntpmsg.precision), ntpmsg.precision,
713 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
714 origin - OFFSET_1900_1970,
715 receive - OFFSET_1900_1970,
716 trans - OFFSET_1900_1970,
717 dest - OFFSET_1900_1970,
720 m->samples_jitter, spike ? " spike" : "",
721 m->poll_interval_usec / USEC_PER_SEC);
724 r = manager_adjust_clock(m, offset, leap_sec);
726 log_error("Failed to call clock_adjtime(): %m");
729 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
730 log_info("%s (%s): interval/delta/delay/jitter/drift %llus/%+.3fs/%.3fs/%.3fs/%+ippm%s",
731 strna(pretty), m->current_server_name->string, m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
732 spike ? " (ignored)" : "");
734 r = manager_arm_timer(m, m->poll_interval_usec);
736 log_error("Failed to rearm timer: %s", strerror(-r));
743 static int manager_listen_setup(Manager *m) {
744 union sockaddr_union addr = {};
745 static const int tos = IPTOS_LOWDELAY;
746 static const int on = 1;
751 assert(m->server_socket < 0);
752 assert(!m->event_receive);
753 assert(m->current_server_address);
755 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
757 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
758 if (m->server_socket < 0)
761 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
765 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
769 setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
771 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
774 static int manager_begin(Manager *m) {
775 _cleanup_free_ char *pretty = NULL;
779 assert_return(m->current_server_name, -EHOSTUNREACH);
780 assert_return(m->current_server_address, -EHOSTUNREACH);
782 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
784 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
785 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
786 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
788 r = manager_listen_setup(m);
790 log_warning("Failed to setup connection socket: %s", strerror(-r));
794 r = manager_clock_watch_setup(m);
798 return manager_send_request(m);
801 static void server_name_flush_addresses(ServerName *n) {
806 while ((a = n->addresses)) {
807 LIST_REMOVE(addresses, n->addresses, a);
812 static void manager_flush_names(Manager *m) {
817 while ((n = m->servers)) {
818 LIST_REMOVE(names, m->servers, n);
820 server_name_flush_addresses(n);
825 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
826 Manager *m = userdata;
827 ServerAddress *a, *last = NULL;
831 assert(m->current_server_name);
833 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
836 log_error("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
839 return manager_connect(m);
842 server_name_flush_addresses(m->current_server_name);
844 for (; ai; ai = ai->ai_next) {
845 _cleanup_free_ char *pretty = NULL;
848 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
849 assert(ai->ai_addrlen <= sizeof(union sockaddr_union));
851 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
852 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
856 a = new0(ServerAddress, 1);
860 memcpy(&a->sockaddr, ai->ai_addr, ai->ai_addrlen);
861 a->socklen = ai->ai_addrlen;
863 LIST_INSERT_AFTER(addresses, m->current_server_name->addresses, last, a);
866 sockaddr_pretty(&a->sockaddr.sa, a->socklen, true, &pretty);
867 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
870 if (!m->current_server_name->addresses) {
871 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
874 return manager_connect(m);
877 m->current_server_address = m->current_server_name->addresses;
879 return manager_begin(m);
882 static int manager_retry(sd_event_source *source, usec_t usec, void *userdata) {
883 Manager *m = userdata;
887 return manager_connect(m);
890 static int manager_connect(Manager *m) {
892 struct addrinfo hints = {
893 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
894 .ai_socktype = SOCK_DGRAM,
900 manager_disconnect(m);
902 m->event_retry = sd_event_source_unref(m->event_retry);
903 if (!ratelimit_test(&m->ratelimit)) {
904 log_debug("Slowing down attempts to contact servers.");
906 r = sd_event_add_time(m->event, &m->event_retry, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + RETRY_USEC, 0, manager_retry, m);
908 log_error("Failed to create retry timer: %s", strerror(-r));
915 /* If we already are operating on some address, switch to the
917 if (m->current_server_address && m->current_server_address->addresses_next)
918 m->current_server_address = m->current_server_address->addresses_next;
920 /* Hmm, we are through all addresses, let's look for the next host instead */
921 m->current_server_address = NULL;
923 if (m->current_server_name && m->current_server_name->names_next)
924 m->current_server_name = m->current_server_name->names_next;
927 m->current_server_name = NULL;
928 log_debug("No server found.");
932 m->current_server_name = m->servers;
935 /* Tell the resolver to reread /etc/resolv.conf, in
936 * case it changed. */
939 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
941 log_error("Failed to create resolver: %s", strerror(-r));
948 r = manager_begin(m);
955 static int manager_add_server(Manager *m, const char *server) {
956 ServerName *n, *tail;
961 n = new0(ServerName, 1);
965 n->string = strdup(server);
971 LIST_FIND_TAIL(names, m->servers, tail);
972 LIST_INSERT_AFTER(names, m->servers, tail, n);
977 static void manager_disconnect(Manager *m) {
980 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
982 m->event_timer = sd_event_source_unref(m->event_timer);
984 m->event_receive = sd_event_source_unref(m->event_receive);
985 m->server_socket = safe_close(m->server_socket);
987 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
988 m->clock_watch_fd = safe_close(m->clock_watch_fd);
990 m->event_timeout = sd_event_source_unref(m->event_timeout);
992 sd_notifyf(false, "STATUS=Idle.");
995 static int manager_new(Manager **ret) {
996 _cleanup_manager_free_ Manager *m = NULL;
999 m = new0(Manager, 1);
1003 m->server_socket = m->clock_watch_fd = -1;
1005 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1007 r = sd_event_default(&m->event);
1011 sd_event_add_signal(m->event, &m->sigterm, SIGTERM, NULL, NULL);
1012 sd_event_add_signal(m->event, &m->sigint, SIGINT, NULL, NULL);
1014 r = sd_resolve_default(&m->resolve);
1018 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1022 r = manager_clock_watch_setup(m);
1032 static void manager_free(Manager *m) {
1036 manager_disconnect(m);
1037 manager_flush_names(m);
1039 sd_event_source_unref(m->sigint);
1040 sd_event_source_unref(m->sigterm);
1042 sd_event_source_unref(m->event_retry);
1044 sd_resolve_unref(m->resolve);
1045 sd_event_unref(m->event);
1050 int main(int argc, char *argv[]) {
1051 _cleanup_manager_free_ Manager *m = NULL;
1055 log_set_target(LOG_TARGET_AUTO);
1056 log_parse_environment();
1059 assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
1061 r = manager_new(&m);
1063 log_error("Failed to allocate manager: %s", strerror(-r));
1067 sd_notify(false, "READY=1");
1069 FOREACH_STRING(x, "8.8.8.8", "172.31.0.1", "time1.google.com", "time2.google.com", "time3.google.com", "time4.google.com", "0.fedora.pool.ntp.org") {
1070 r = manager_add_server(m, x);
1072 log_error("Failed to add server %s: %s", x, strerror(-r));
1077 r = manager_connect(m);
1081 r = sd_event_loop(m->event);
1083 log_error("Failed to run event loop: %s", strerror(-r));
1087 sd_event_get_exit_code(m->event, &r);
1090 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;