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>
39 #include "sparse-endian.h"
41 #include "socket-util.h"
43 #include "ratelimit.h"
45 #include "conf-parser.h"
47 #include "sd-resolve.h"
48 #include "sd-daemon.h"
49 #include "sd-network.h"
50 #include "event-util.h"
51 #include "network-util.h"
52 #include "timesyncd.h"
54 #define TIME_T_MAX (time_t)((1UL << ((sizeof(time_t) << 3) - 1)) - 1)
57 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
60 /* expected accuracy of time synchronization; used to adjust the poll interval */
61 #define NTP_ACCURACY_SEC 0.2
64 * "A client MUST NOT under any conditions use a poll interval less
67 #define NTP_POLL_INTERVAL_MIN_SEC 32
68 #define NTP_POLL_INTERVAL_MAX_SEC 2048
71 * Maximum delta in seconds which the system clock is gradually adjusted
72 * (slew) to approach the network time. Deltas larger that this are set by
73 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
75 #define NTP_MAX_ADJUST 0.4
77 /* NTP protocol, packet header */
78 #define NTP_LEAP_PLUSSEC 1
79 #define NTP_LEAP_MINUSSEC 2
80 #define NTP_LEAP_NOTINSYNC 3
81 #define NTP_MODE_CLIENT 3
82 #define NTP_MODE_SERVER 4
83 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
84 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
85 #define NTP_FIELD_MODE(f) ((f) & 7)
86 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
89 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
90 * in seconds relative to 0h on 1 January 1900."
92 #define OFFSET_1900_1970 2208988800UL
94 #define RETRY_USEC (30*USEC_PER_SEC)
95 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
96 #define RATELIMIT_BURST 10
98 #define TIMEOUT_USEC (10*USEC_PER_SEC)
105 struct ntp_ts_short {
115 struct ntp_ts_short root_delay;
116 struct ntp_ts_short root_dispersion;
118 struct ntp_ts reference_time;
119 struct ntp_ts origin_time;
120 struct ntp_ts recv_time;
121 struct ntp_ts trans_time;
124 static void manager_free(Manager *m);
125 DEFINE_TRIVIAL_CLEANUP_FUNC(Manager*, manager_free);
126 #define _cleanup_manager_free_ _cleanup_(manager_freep)
128 static int manager_arm_timer(Manager *m, usec_t next);
129 static int manager_clock_watch_setup(Manager *m);
130 static int manager_connect(Manager *m);
131 static void manager_disconnect(Manager *m);
133 static double ntp_ts_to_d(const struct ntp_ts *ts) {
134 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
137 static double ts_to_d(const struct timespec *ts) {
138 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
141 static double tv_to_d(const struct timeval *tv) {
142 return tv->tv_sec + (1.0e-6 * tv->tv_usec);
145 static double square(double d) {
149 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
150 _cleanup_free_ char *pretty = NULL;
151 Manager *m = userdata;
154 assert(m->current_server_name);
155 assert(m->current_server_address);
157 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
158 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
160 return manager_connect(m);
163 static int manager_send_request(Manager *m) {
164 _cleanup_free_ char *pretty = NULL;
165 struct ntp_msg ntpmsg = {
167 * "The client initializes the NTP message header, sends the request
168 * to the server, and strips the time of day from the Transmit
169 * Timestamp field of the reply. For this purpose, all the NTP
170 * header fields are set to 0, except the Mode, VN, and optional
171 * Transmit Timestamp fields."
173 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
179 assert(m->current_server_name);
180 assert(m->current_server_address);
182 m->event_timeout = sd_event_source_unref(m->event_timeout);
185 * Set transmit timestamp, remember it; the server will send that back
186 * as the origin timestamp and we have an indication that this is the
187 * matching answer to our request.
189 * The actual value does not matter, We do not care about the correct
190 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
192 assert_se(clock_gettime(CLOCK_MONOTONIC, &m->trans_time_mon) >= 0);
193 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
194 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
195 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
197 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
199 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
200 if (len == sizeof(ntpmsg)) {
202 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
204 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
205 return manager_connect(m);
208 /* re-arm timer with incresing timeout, in case the packets never arrive back */
209 if (m->retry_interval > 0) {
210 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
211 m->retry_interval *= 2;
213 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
215 r = manager_arm_timer(m, m->retry_interval);
217 log_error("Failed to rearm timer: %s", strerror(-r));
221 r = sd_event_add_time(
225 now(CLOCK_MONOTONIC) + TIMEOUT_USEC, 0,
228 log_error("Failed to arm timeout timer: %s", strerror(-r));
235 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
236 Manager *m = userdata;
240 return manager_send_request(m);
243 static int manager_arm_timer(Manager *m, usec_t next) {
247 assert(m->event_receive);
250 m->event_timer = sd_event_source_unref(m->event_timer);
254 if (m->event_timer) {
255 r = sd_event_source_set_time(m->event_timer, now(CLOCK_MONOTONIC) + next);
259 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
262 return sd_event_add_time(
266 now(CLOCK_MONOTONIC) + next, 0,
270 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
271 Manager *m = userdata;
276 manager_clock_watch_setup(m);
278 /* skip our own jumps */
285 log_info("System time changed. Resyncing.");
286 m->poll_resync = true;
287 return manager_send_request(m);
290 /* wake up when the system time changes underneath us */
291 static int manager_clock_watch_setup(Manager *m) {
293 struct itimerspec its = {
294 .it_value.tv_sec = TIME_T_MAX
301 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
302 safe_close(m->clock_watch_fd);
304 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
305 if (m->clock_watch_fd < 0) {
306 log_error("Failed to create timerfd: %m");
310 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
311 log_error("Failed to set up timerfd: %m");
315 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
317 log_error("Failed to create clock watch event source: %s", strerror(-r));
324 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
325 struct timex tmx = {};
331 * For small deltas, tell the kernel to gradually adjust the system
332 * clock to the NTP time, larger deltas are just directly set.
334 * Clear STA_UNSYNC, it will enable the kernel's 11-minute mode, which
335 * syncs the system time periodically to the hardware clock.
337 if (fabs(offset) < NTP_MAX_ADJUST) {
338 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
339 tmx.status = STA_PLL;
340 tmx.offset = offset * NSEC_PER_SEC;
341 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
344 log_debug(" adjust (slew): %+.3f sec\n", offset);
346 tmx.modes = ADJ_SETOFFSET | ADJ_NANO;
348 /* ADJ_NANO uses nanoseconds in the microseconds field */
349 tmx.time.tv_sec = (long)offset;
350 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
352 /* the kernel expects -0.3s as {-1, 7000.000.000} */
353 if (tmx.time.tv_usec < 0) {
354 tmx.time.tv_sec -= 1;
355 tmx.time.tv_usec += NSEC_PER_SEC;
359 log_debug(" adjust (jump): %+.3f sec\n", offset);
364 tmx.status |= STA_INS;
367 tmx.status |= STA_DEL;
371 r = clock_adjtime(CLOCK_REALTIME, &tmx);
375 m->drift_ppm = tmx.freq / 65536;
377 log_debug(" status : %04i %s\n"
378 " time now : %li.%03lli\n"
380 " offset : %+.3f sec\n"
381 " freq offset : %+li (%i ppm)\n",
382 tmx.status, tmx.status & STA_UNSYNC ? "" : "sync",
383 tmx.time.tv_sec, tmx.time.tv_usec / NSEC_PER_MSEC,
385 (double)tmx.offset / NSEC_PER_SEC,
386 tmx.freq, m->drift_ppm);
391 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
392 unsigned int i, idx_cur, idx_new, idx_min;
400 /* ignore initial sample */
401 if (m->packet_count == 1)
404 /* store the current data in our samples array */
405 idx_cur = m->samples_idx;
406 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
407 m->samples_idx = idx_new;
408 m->samples[idx_new].offset = offset;
409 m->samples[idx_new].delay = delay;
411 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
412 jitter = m->samples_jitter;
413 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
414 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
418 for (i = 0; i < ELEMENTSOF(m->samples); i++)
419 j += square(m->samples[i].offset - m->samples[idx_min].offset);
420 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
422 /* ignore samples when resyncing */
426 /* always accept offset if we are farther off than the round-trip delay */
427 if (fabs(offset) > delay)
430 /* we need a few samples before looking at them */
431 if (m->packet_count < 4)
434 /* do not accept anything worse than the maximum possible error of the best sample */
435 if (fabs(offset) > m->samples[idx_min].delay)
438 /* compare the difference between the current offset to the previous offset and jitter */
439 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
442 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
445 if (m->poll_resync) {
446 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
447 m->poll_resync = false;
451 /* set to minimal poll interval */
452 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
453 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
457 /* increase polling interval */
458 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
459 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
460 m->poll_interval_usec *= 2;
464 /* decrease polling interval */
465 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
466 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
467 m->poll_interval_usec /= 2;
472 static bool sockaddr_equal(union sockaddr_union *a, union sockaddr_union *b) {
476 if (a->sa.sa_family != b->sa.sa_family)
479 if (a->sa.sa_family == AF_INET)
480 return a->in.sin_addr.s_addr == b->in.sin_addr.s_addr;
482 if (a->sa.sa_family == AF_INET6)
483 return memcmp(&a->in6.sin6_addr, &b->in6.sin6_addr, sizeof(a->in6.sin6_addr)) == 0;
488 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
489 Manager *m = userdata;
490 struct ntp_msg ntpmsg;
494 .iov_len = sizeof(ntpmsg),
497 struct cmsghdr cmsghdr;
498 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
500 union sockaddr_union server_addr;
501 struct msghdr msghdr = {
504 .msg_control = &control,
505 .msg_controllen = sizeof(control),
506 .msg_name = &server_addr,
507 .msg_namelen = sizeof(server_addr),
509 struct cmsghdr *cmsg;
510 struct timespec now_ts;
511 struct timeval *recv_time;
513 double origin, receive, trans, dest;
514 double delay, offset;
522 if (revents & (EPOLLHUP|EPOLLERR)) {
523 log_warning("Server connection returned error.");
524 return manager_connect(m);
527 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
532 log_warning("Error receiving message. Disconnecting.");
533 return manager_connect(m);
536 if (iov.iov_len < sizeof(struct ntp_msg)) {
537 log_warning("Invalid response from server. Disconnecting.");
538 return manager_connect(m);
541 if (!m->current_server_name ||
542 !m->current_server_address ||
543 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
544 log_debug("Response from unknown server.");
549 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
550 if (cmsg->cmsg_level != SOL_SOCKET)
553 switch (cmsg->cmsg_type) {
555 recv_time = (struct timeval *) CMSG_DATA(cmsg);
560 log_error("Invalid packet timestamp.");
565 log_debug("Unexpected reply. Ignoring.");
569 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
570 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
571 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
572 log_debug("Invalid reply; not our transmit time. Ignoring.");
576 m->event_timeout = sd_event_source_unref(m->event_timeout);
578 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
579 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
580 log_debug("Invalid reply, returned times before epoch. Ignoring.");
581 return manager_connect(m);
584 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC) {
585 log_debug("Server is not synchronized. Disconnecting.");
586 return manager_connect(m);
589 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
590 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
591 return manager_connect(m);
594 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
595 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
596 return manager_connect(m);
601 m->retry_interval = 0;
603 /* announce leap seconds */
604 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
606 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
612 * "Timestamp Name ID When Generated
613 * ------------------------------------------------------------
614 * Originate Timestamp T1 time request sent by client
615 * Receive Timestamp T2 time request received by server
616 * Transmit Timestamp T3 time reply sent by server
617 * Destination Timestamp T4 time reply received by client
619 * The round-trip delay, d, and system clock offset, t, are defined as:
620 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
622 assert_se(clock_gettime(CLOCK_MONOTONIC, &now_ts) >= 0);
623 origin = tv_to_d(recv_time) - (ts_to_d(&now_ts) - ts_to_d(&m->trans_time_mon)) + OFFSET_1900_1970;
624 receive = ntp_ts_to_d(&ntpmsg.recv_time);
625 trans = ntp_ts_to_d(&ntpmsg.trans_time);
626 dest = tv_to_d(recv_time) + OFFSET_1900_1970;
628 offset = ((receive - origin) + (trans - dest)) / 2;
629 delay = (dest - origin) - (trans - receive);
631 spike = manager_sample_spike_detection(m, offset, delay);
633 manager_adjust_poll(m, offset, spike);
635 log_debug("NTP response:\n"
640 " precision : %.6f sec (%d)\n"
641 " reference : %.4s\n"
646 " offset : %+.3f sec\n"
647 " delay : %+.3f sec\n"
648 " packet count : %"PRIu64"\n"
650 " poll interval: %llu\n",
651 NTP_FIELD_LEAP(ntpmsg.field),
652 NTP_FIELD_VERSION(ntpmsg.field),
653 NTP_FIELD_MODE(ntpmsg.field),
655 exp2(ntpmsg.precision), ntpmsg.precision,
656 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
657 origin - OFFSET_1900_1970,
658 receive - OFFSET_1900_1970,
659 trans - OFFSET_1900_1970,
660 dest - OFFSET_1900_1970,
663 m->samples_jitter, spike ? " spike" : "",
664 m->poll_interval_usec / USEC_PER_SEC);
667 r = manager_adjust_clock(m, offset, leap_sec);
669 log_error("Failed to call clock_adjtime(): %m");
672 log_info("interval/delta/delay/jitter/drift %llus/%+.3fs/%.3fs/%.3fs/%+ippm%s",
673 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
674 spike ? " (ignored)" : "");
676 r = manager_arm_timer(m, m->poll_interval_usec);
678 log_error("Failed to rearm timer: %s", strerror(-r));
685 static int manager_listen_setup(Manager *m) {
686 union sockaddr_union addr = {};
687 static const int tos = IPTOS_LOWDELAY;
688 static const int on = 1;
693 assert(m->server_socket < 0);
694 assert(!m->event_receive);
695 assert(m->current_server_address);
697 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
699 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
700 if (m->server_socket < 0)
703 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
707 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMP, &on, sizeof(on));
711 setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
713 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
716 static int manager_begin(Manager *m) {
717 _cleanup_free_ char *pretty = NULL;
721 assert_return(m->current_server_name, -EHOSTUNREACH);
722 assert_return(m->current_server_address, -EHOSTUNREACH);
724 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
726 sockaddr_pretty(&m->current_server_address->sockaddr.sa, m->current_server_address->socklen, true, &pretty);
727 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
728 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
730 r = manager_listen_setup(m);
732 log_warning("Failed to setup connection socket: %s", strerror(-r));
736 r = manager_clock_watch_setup(m);
740 return manager_send_request(m);
743 static void server_name_flush_addresses(ServerName *n) {
748 while ((a = n->addresses)) {
749 LIST_REMOVE(addresses, n->addresses, a);
754 static void manager_flush_names(Manager *m) {
759 while ((n = m->servers)) {
760 LIST_REMOVE(names, m->servers, n);
762 server_name_flush_addresses(n);
767 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
768 Manager *m = userdata;
769 ServerAddress *a, *last = NULL;
773 assert(m->current_server_name);
775 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
778 log_info("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
781 return manager_connect(m);
784 server_name_flush_addresses(m->current_server_name);
786 for (; ai; ai = ai->ai_next) {
787 _cleanup_free_ char *pretty = NULL;
790 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
791 assert(ai->ai_addrlen <= sizeof(union sockaddr_union));
793 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
794 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
798 a = new0(ServerAddress, 1);
802 memcpy(&a->sockaddr, ai->ai_addr, ai->ai_addrlen);
803 a->socklen = ai->ai_addrlen;
805 LIST_INSERT_AFTER(addresses, m->current_server_name->addresses, last, a);
808 sockaddr_pretty(&a->sockaddr.sa, a->socklen, true, &pretty);
809 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
812 if (!m->current_server_name->addresses) {
813 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
816 return manager_connect(m);
819 m->current_server_address = m->current_server_name->addresses;
821 return manager_begin(m);
824 static int manager_retry(sd_event_source *source, usec_t usec, void *userdata) {
825 Manager *m = userdata;
829 return manager_connect(m);
832 static int manager_connect(Manager *m) {
834 struct addrinfo hints = {
835 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
836 .ai_socktype = SOCK_DGRAM,
842 manager_disconnect(m);
844 m->event_retry = sd_event_source_unref(m->event_retry);
845 if (!ratelimit_test(&m->ratelimit)) {
846 log_debug("Slowing down attempts to contact servers.");
848 r = sd_event_add_time(m->event, &m->event_retry, CLOCK_MONOTONIC, now(CLOCK_MONOTONIC) + RETRY_USEC, 0, manager_retry, m);
850 log_error("Failed to create retry timer: %s", strerror(-r));
857 /* If we already are operating on some address, switch to the
859 if (m->current_server_address && m->current_server_address->addresses_next)
860 m->current_server_address = m->current_server_address->addresses_next;
862 /* Hmm, we are through all addresses, let's look for the next host instead */
863 m->current_server_address = NULL;
865 if (m->current_server_name && m->current_server_name->names_next)
866 m->current_server_name = m->current_server_name->names_next;
869 m->current_server_name = NULL;
870 log_debug("No server found.");
874 m->current_server_name = m->servers;
877 /* Tell the resolver to reread /etc/resolv.conf, in
878 * case it changed. */
881 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
883 log_error("Failed to create resolver: %s", strerror(-r));
890 r = manager_begin(m);
897 static int manager_add_server(Manager *m, const char *server) {
898 ServerName *n, *tail;
903 n = new0(ServerName, 1);
907 n->string = strdup(server);
913 LIST_FIND_TAIL(names, m->servers, tail);
914 LIST_INSERT_AFTER(names, m->servers, tail, n);
919 static int manager_add_server_string(Manager *m, const char *string) {
927 FOREACH_WORD_QUOTED(w, l, string, state) {
933 r = manager_add_server(m, t);
935 log_error("Failed to add server %s to configuration, ignoring: %s", t, strerror(-r));
941 static void manager_disconnect(Manager *m) {
944 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
946 m->event_timer = sd_event_source_unref(m->event_timer);
948 m->event_receive = sd_event_source_unref(m->event_receive);
949 m->server_socket = safe_close(m->server_socket);
951 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
952 m->clock_watch_fd = safe_close(m->clock_watch_fd);
954 m->event_timeout = sd_event_source_unref(m->event_timeout);
956 sd_notifyf(false, "STATUS=Idle.");
959 static int manager_new(Manager **ret) {
960 _cleanup_manager_free_ Manager *m = NULL;
963 m = new0(Manager, 1);
967 m->server_socket = m->clock_watch_fd = -1;
969 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
971 r = sd_event_default(&m->event);
975 sd_event_add_signal(m->event, &m->sigterm, SIGTERM, NULL, NULL);
976 sd_event_add_signal(m->event, &m->sigint, SIGINT, NULL, NULL);
978 r = sd_resolve_default(&m->resolve);
982 r = sd_resolve_attach_event(m->resolve, m->event, 0);
986 r = manager_clock_watch_setup(m);
996 static void manager_free(Manager *m) {
1000 manager_disconnect(m);
1001 manager_flush_names(m);
1003 sd_event_source_unref(m->sigint);
1004 sd_event_source_unref(m->sigterm);
1006 sd_event_source_unref(m->event_retry);
1008 sd_event_source_unref(m->network_event_source);
1009 sd_network_monitor_unref(m->network_monitor);
1011 sd_resolve_unref(m->resolve);
1012 sd_event_unref(m->event);
1017 int config_parse_servers(
1019 const char *filename,
1021 const char *section,
1022 unsigned section_line,
1029 Manager *m = userdata;
1035 manager_flush_names(m);
1036 manager_add_server_string(m, rvalue);
1041 static int manager_parse_config_file(Manager *m) {
1042 static const char fn[] = "/etc/systemd/timesyncd.conf";
1043 _cleanup_fclose_ FILE *f = NULL;
1048 f = fopen(fn, "re");
1050 if (errno == ENOENT)
1053 log_warning("Failed to open configuration file %s: %m", fn);
1057 r = config_parse(NULL, fn, f, "Time\0", config_item_perf_lookup,
1058 (void*) timesyncd_gperf_lookup, false, false, m);
1060 log_warning("Failed to parse configuration file: %s", strerror(-r));
1065 static bool network_is_online(void) {
1066 _cleanup_free_ char *state = NULL;
1069 r = sd_network_get_operational_state(&state);
1070 if (r >= 0 && streq("carrier", state))
1076 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents,
1078 Manager *m = userdata;
1079 bool connected, online;
1084 /* check if the machine is online */
1085 online = network_is_online();
1087 /* check if the client is currently connected */
1088 connected = (m->server_socket != -1);
1090 if (connected && !online) {
1091 log_info("No network connectivity. Suspending.");
1092 manager_disconnect(m);
1093 } else if (!connected && online) {
1094 log_info("Network connectivity detected. Resuming.");
1095 if (m->current_server_address) {
1096 r = manager_begin(m);
1100 r = manager_connect(m);
1106 sd_network_monitor_flush(m->network_monitor);
1111 static int manager_network_monitor_listen(Manager *m) {
1112 _cleanup_event_source_unref_ sd_event_source *event_source = NULL;
1113 _cleanup_network_monitor_unref_ sd_network_monitor *monitor = NULL;
1116 r = sd_network_monitor_new(NULL, &monitor);
1120 fd = sd_network_monitor_get_fd(monitor);
1124 events = sd_network_monitor_get_events(monitor);
1128 r = sd_event_add_io(m->event, &event_source, fd, events,
1129 &manager_network_event_handler, m);
1133 m->network_monitor = monitor;
1134 m->network_event_source = event_source;
1136 event_source = NULL;
1141 int main(int argc, char *argv[]) {
1142 _cleanup_manager_free_ Manager *m = NULL;
1146 log_error("This program does not take arguments.");
1147 return EXIT_FAILURE;
1150 log_set_target(LOG_TARGET_AUTO);
1151 log_set_facility(LOG_CRON);
1152 log_parse_environment();
1157 assert_se(sigprocmask_many(SIG_BLOCK, SIGTERM, SIGINT, -1) == 0);
1159 r = manager_new(&m);
1161 log_error("Failed to allocate manager: %s", strerror(-r));
1165 manager_add_server_string(m, NTP_SERVERS);
1166 manager_parse_config_file(m);
1168 r = manager_network_monitor_listen(m);
1170 log_error("Failed to listen to networkd events: %s", strerror(-r));
1174 log_debug("systemd-timesyncd running as pid %lu", (unsigned long) getpid());
1175 sd_notify(false, "READY=1");
1177 if (network_is_online()) {
1178 r = manager_connect(m);
1183 r = sd_event_loop(m->event);
1185 log_error("Failed to run event loop: %s", strerror(-r));
1189 sd_event_get_exit_code(m->event, &r);
1192 sd_notify(false, "STATUS=Shutting down...");
1194 return r < 0 ? EXIT_FAILURE : EXIT_SUCCESS;