1 /* SPDX-License-Identifier: LGPL-2.1+ */
3 This file is part of systemd.
5 Copyright 2014 Kay Sievers, Lennart Poettering
7 systemd is free software; you can redistribute it and/or modify it
8 under the terms of the GNU Lesser General Public License as published by
9 the Free Software Foundation; either version 2.1 of the License, or
10 (at your option) any later version.
12 systemd is distributed in the hope that it will be useful, but
13 WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
15 Lesser General Public License for more details.
17 You should have received a copy of the GNU Lesser General Public License
18 along with systemd; If not, see <http://www.gnu.org/licenses/>.
23 #include <netinet/in.h>
24 #include <netinet/ip.h>
27 #include <sys/socket.h>
28 #include <sys/timerfd.h>
29 #include <sys/timex.h>
30 #include <sys/types.h>
33 #include "sd-daemon.h"
35 #include "alloc-util.h"
41 #include "network-util.h"
42 #include "ratelimit.h"
43 #include "socket-util.h"
44 #include "sparse-endian.h"
45 #include "string-util.h"
47 #include "time-util.h"
48 #include "timesyncd-conf.h"
49 #include "timesyncd-manager.h"
53 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
56 /* expected accuracy of time synchronization; used to adjust the poll interval */
57 #define NTP_ACCURACY_SEC 0.2
60 * Maximum delta in seconds which the system clock is gradually adjusted
61 * (slewed) to approach the network time. Deltas larger that this are set by
62 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
64 #define NTP_MAX_ADJUST 0.4
66 /* NTP protocol, packet header */
67 #define NTP_LEAP_PLUSSEC 1
68 #define NTP_LEAP_MINUSSEC 2
69 #define NTP_LEAP_NOTINSYNC 3
70 #define NTP_MODE_CLIENT 3
71 #define NTP_MODE_SERVER 4
72 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
73 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
74 #define NTP_FIELD_MODE(f) ((f) & 7)
75 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
77 /* Default of maximum acceptable root distance in microseconds. */
78 #define NTP_MAX_ROOT_DISTANCE (5 * USEC_PER_SEC)
80 /* Maximum number of missed replies before selecting another source. */
81 #define NTP_MAX_MISSED_REPLIES 2
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 UINT64_C(2208988800)
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 static int manager_arm_timer(Manager
*m
, usec_t next
);
120 static int manager_clock_watch_setup(Manager
*m
);
121 static int manager_listen_setup(Manager
*m
);
122 static void manager_listen_stop(Manager
*m
);
124 static double ntp_ts_short_to_d(const struct ntp_ts_short
*ts
) {
125 return be16toh(ts
->sec
) + (be16toh(ts
->frac
) / 65536.0);
128 static double ntp_ts_to_d(const struct ntp_ts
*ts
) {
129 return be32toh(ts
->sec
) + ((double)be32toh(ts
->frac
) / UINT_MAX
);
132 static double ts_to_d(const struct timespec
*ts
) {
133 return ts
->tv_sec
+ (1.0e-9 * ts
->tv_nsec
);
136 static int manager_timeout(sd_event_source
*source
, usec_t usec
, void *userdata
) {
137 _cleanup_free_
char *pretty
= NULL
;
138 Manager
*m
= userdata
;
141 assert(m
->current_server_name
);
142 assert(m
->current_server_address
);
144 server_address_pretty(m
->current_server_address
, &pretty
);
145 log_info("Timed out waiting for reply from %s (%s).", strna(pretty
), m
->current_server_name
->string
);
147 return manager_connect(m
);
150 static int manager_send_request(Manager
*m
) {
151 _cleanup_free_
char *pretty
= NULL
;
152 struct ntp_msg ntpmsg
= {
154 * "The client initializes the NTP message header, sends the request
155 * to the server, and strips the time of day from the Transmit
156 * Timestamp field of the reply. For this purpose, all the NTP
157 * header fields are set to 0, except the Mode, VN, and optional
158 * Transmit Timestamp fields."
160 .field
= NTP_FIELD(0, 4, NTP_MODE_CLIENT
),
166 assert(m
->current_server_name
);
167 assert(m
->current_server_address
);
169 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
171 r
= manager_listen_setup(m
);
173 return log_warning_errno(r
, "Failed to setup connection socket: %m");
176 * Set transmit timestamp, remember it; the server will send that back
177 * as the origin timestamp and we have an indication that this is the
178 * matching answer to our request.
180 * The actual value does not matter, We do not care about the correct
181 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
183 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m
->trans_time_mon
) >= 0);
184 assert_se(clock_gettime(CLOCK_REALTIME
, &m
->trans_time
) >= 0);
185 ntpmsg
.trans_time
.sec
= htobe32(m
->trans_time
.tv_sec
+ OFFSET_1900_1970
);
186 ntpmsg
.trans_time
.frac
= htobe32(m
->trans_time
.tv_nsec
);
188 server_address_pretty(m
->current_server_address
, &pretty
);
190 len
= sendto(m
->server_socket
, &ntpmsg
, sizeof(ntpmsg
), MSG_DONTWAIT
, &m
->current_server_address
->sockaddr
.sa
, m
->current_server_address
->socklen
);
191 if (len
== sizeof(ntpmsg
)) {
193 log_debug("Sent NTP request to %s (%s).", strna(pretty
), m
->current_server_name
->string
);
195 log_debug_errno(errno
, "Sending NTP request to %s (%s) failed: %m", strna(pretty
), m
->current_server_name
->string
);
196 return manager_connect(m
);
199 /* re-arm timer with increasing timeout, in case the packets never arrive back */
200 if (m
->retry_interval
> 0) {
201 if (m
->retry_interval
< m
->poll_interval_max_usec
)
202 m
->retry_interval
*= 2;
204 m
->retry_interval
= m
->poll_interval_min_usec
;
206 r
= manager_arm_timer(m
, m
->retry_interval
);
208 return log_error_errno(r
, "Failed to rearm timer: %m");
211 if (m
->missed_replies
> NTP_MAX_MISSED_REPLIES
) {
212 r
= sd_event_add_time(
215 clock_boottime_or_monotonic(),
216 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC
, 0,
219 return log_error_errno(r
, "Failed to arm timeout timer: %m");
225 static int manager_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
226 Manager
*m
= userdata
;
230 return manager_send_request(m
);
233 static int manager_arm_timer(Manager
*m
, usec_t next
) {
239 m
->event_timer
= sd_event_source_unref(m
->event_timer
);
243 if (m
->event_timer
) {
244 r
= sd_event_source_set_time(m
->event_timer
, now(clock_boottime_or_monotonic()) + next
);
248 return sd_event_source_set_enabled(m
->event_timer
, SD_EVENT_ONESHOT
);
251 return sd_event_add_time(
254 clock_boottime_or_monotonic(),
255 now(clock_boottime_or_monotonic()) + next
, 0,
259 static int manager_clock_watch(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
260 Manager
*m
= userdata
;
265 manager_clock_watch_setup(m
);
267 /* skip our own jumps */
274 log_debug("System time changed. Resyncing.");
275 m
->poll_resync
= true;
277 return manager_send_request(m
);
280 /* wake up when the system time changes underneath us */
281 static int manager_clock_watch_setup(Manager
*m
) {
283 struct itimerspec its
= {
284 .it_value
.tv_sec
= TIME_T_MAX
291 m
->event_clock_watch
= sd_event_source_unref(m
->event_clock_watch
);
292 safe_close(m
->clock_watch_fd
);
294 m
->clock_watch_fd
= timerfd_create(CLOCK_REALTIME
, TFD_NONBLOCK
|TFD_CLOEXEC
);
295 if (m
->clock_watch_fd
< 0)
296 return log_error_errno(errno
, "Failed to create timerfd: %m");
298 if (timerfd_settime(m
->clock_watch_fd
, TFD_TIMER_ABSTIME
|TFD_TIMER_CANCEL_ON_SET
, &its
, NULL
) < 0)
299 return log_error_errno(errno
, "Failed to set up timerfd: %m");
301 r
= sd_event_add_io(m
->event
, &m
->event_clock_watch
, m
->clock_watch_fd
, EPOLLIN
, manager_clock_watch
, m
);
303 return log_error_errno(r
, "Failed to create clock watch event source: %m");
308 static int manager_adjust_clock(Manager
*m
, double offset
, int leap_sec
) {
309 struct timex tmx
= {};
315 * For small deltas, tell the kernel to gradually adjust the system
316 * clock to the NTP time, larger deltas are just directly set.
318 if (fabs(offset
) < NTP_MAX_ADJUST
) {
319 tmx
.modes
= ADJ_STATUS
| ADJ_NANO
| ADJ_OFFSET
| ADJ_TIMECONST
| ADJ_MAXERROR
| ADJ_ESTERROR
;
320 tmx
.status
= STA_PLL
;
321 tmx
.offset
= offset
* NSEC_PER_SEC
;
322 tmx
.constant
= log2i(m
->poll_interval_usec
/ USEC_PER_SEC
) - 4;
325 log_debug(" adjust (slew): %+.3f sec", offset
);
327 tmx
.modes
= ADJ_STATUS
| ADJ_NANO
| ADJ_SETOFFSET
| ADJ_MAXERROR
| ADJ_ESTERROR
;
329 /* ADJ_NANO uses nanoseconds in the microseconds field */
330 tmx
.time
.tv_sec
= (long)offset
;
331 tmx
.time
.tv_usec
= (offset
- tmx
.time
.tv_sec
) * NSEC_PER_SEC
;
335 /* the kernel expects -0.3s as {-1, 7000.000.000} */
336 if (tmx
.time
.tv_usec
< 0) {
337 tmx
.time
.tv_sec
-= 1;
338 tmx
.time
.tv_usec
+= NSEC_PER_SEC
;
342 log_debug(" adjust (jump): %+.3f sec", offset
);
346 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
347 * which syncs the system time periodically to the RTC.
349 * In case the RTC runs in local time, never touch the RTC,
350 * we have no way to properly handle daylight saving changes and
351 * mobile devices moving between time zones.
353 if (m
->rtc_local_time
)
354 tmx
.status
|= STA_UNSYNC
;
358 tmx
.status
|= STA_INS
;
361 tmx
.status
|= STA_DEL
;
365 r
= clock_adjtime(CLOCK_REALTIME
, &tmx
);
369 /* If touch fails, there isn't much we can do. Maybe it'll work next time. */
370 (void) touch("/var/lib/systemd/timesync/clock");
372 m
->drift_ppm
= tmx
.freq
/ 65536;
374 log_debug(" status : %04i %s\n"
375 " time now : %"PRI_TIME
".%03"PRI_USEC
"\n"
376 " constant : %"PRI_TIMEX
"\n"
377 " offset : %+.3f sec\n"
378 " freq offset : %+"PRI_TIMEX
" (%i ppm)\n",
379 tmx
.status
, tmx
.status
& STA_UNSYNC
? "unsync" : "sync",
380 tmx
.time
.tv_sec
, tmx
.time
.tv_usec
/ NSEC_PER_MSEC
,
382 (double)tmx
.offset
/ NSEC_PER_SEC
,
383 tmx
.freq
, m
->drift_ppm
);
388 static bool manager_sample_spike_detection(Manager
*m
, double offset
, double delay
) {
389 unsigned int i
, idx_cur
, idx_new
, idx_min
;
397 /* ignore initial sample */
398 if (m
->packet_count
== 1)
401 /* store the current data in our samples array */
402 idx_cur
= m
->samples_idx
;
403 idx_new
= (idx_cur
+ 1) % ELEMENTSOF(m
->samples
);
404 m
->samples_idx
= idx_new
;
405 m
->samples
[idx_new
].offset
= offset
;
406 m
->samples
[idx_new
].delay
= delay
;
408 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
409 jitter
= m
->samples_jitter
;
410 for (idx_min
= idx_cur
, i
= 0; i
< ELEMENTSOF(m
->samples
); i
++)
411 if (m
->samples
[i
].delay
> 0 && m
->samples
[i
].delay
< m
->samples
[idx_min
].delay
)
415 for (i
= 0; i
< ELEMENTSOF(m
->samples
); i
++)
416 j
+= pow(m
->samples
[i
].offset
- m
->samples
[idx_min
].offset
, 2);
417 m
->samples_jitter
= sqrt(j
/ (ELEMENTSOF(m
->samples
) - 1));
419 /* ignore samples when resyncing */
423 /* always accept offset if we are farther off than the round-trip delay */
424 if (fabs(offset
) > delay
)
427 /* we need a few samples before looking at them */
428 if (m
->packet_count
< 4)
431 /* do not accept anything worse than the maximum possible error of the best sample */
432 if (fabs(offset
) > m
->samples
[idx_min
].delay
)
435 /* compare the difference between the current offset to the previous offset and jitter */
436 return fabs(offset
- m
->samples
[idx_cur
].offset
) > 3 * jitter
;
439 static void manager_adjust_poll(Manager
*m
, double offset
, bool spike
) {
442 if (m
->poll_resync
) {
443 m
->poll_interval_usec
= m
->poll_interval_min_usec
;
444 m
->poll_resync
= false;
448 /* set to minimal poll interval */
449 if (!spike
&& fabs(offset
) > NTP_ACCURACY_SEC
) {
450 m
->poll_interval_usec
= m
->poll_interval_min_usec
;
454 /* increase polling interval */
455 if (fabs(offset
) < NTP_ACCURACY_SEC
* 0.25) {
456 if (m
->poll_interval_usec
< m
->poll_interval_max_usec
)
457 m
->poll_interval_usec
*= 2;
461 /* decrease polling interval */
462 if (spike
|| fabs(offset
) > NTP_ACCURACY_SEC
* 0.75) {
463 if (m
->poll_interval_usec
> m
->poll_interval_min_usec
)
464 m
->poll_interval_usec
/= 2;
469 static int manager_receive_response(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
470 Manager
*m
= userdata
;
471 struct ntp_msg ntpmsg
;
475 .iov_len
= sizeof(ntpmsg
),
478 struct cmsghdr cmsghdr
;
479 uint8_t buf
[CMSG_SPACE(sizeof(struct timeval
))];
481 union sockaddr_union server_addr
;
482 struct msghdr msghdr
= {
485 .msg_control
= &control
,
486 .msg_controllen
= sizeof(control
),
487 .msg_name
= &server_addr
,
488 .msg_namelen
= sizeof(server_addr
),
490 struct cmsghdr
*cmsg
;
491 struct timespec
*recv_time
= NULL
;
493 double origin
, receive
, trans
, dest
;
494 double delay
, offset
;
495 double root_distance
;
503 if (revents
& (EPOLLHUP
|EPOLLERR
)) {
504 log_warning("Server connection returned error.");
505 return manager_connect(m
);
508 len
= recvmsg(fd
, &msghdr
, MSG_DONTWAIT
);
513 log_warning("Error receiving message. Disconnecting.");
514 return manager_connect(m
);
517 /* Too short or too long packet? */
518 if (iov
.iov_len
< sizeof(struct ntp_msg
) || (msghdr
.msg_flags
& MSG_TRUNC
)) {
519 log_warning("Invalid response from server. Disconnecting.");
520 return manager_connect(m
);
523 if (!m
->current_server_name
||
524 !m
->current_server_address
||
525 !sockaddr_equal(&server_addr
, &m
->current_server_address
->sockaddr
)) {
526 log_debug("Response from unknown server.");
530 CMSG_FOREACH(cmsg
, &msghdr
) {
531 if (cmsg
->cmsg_level
!= SOL_SOCKET
)
534 switch (cmsg
->cmsg_type
) {
535 case SCM_TIMESTAMPNS
:
536 recv_time
= (struct timespec
*) CMSG_DATA(cmsg
);
541 log_error("Invalid packet timestamp.");
546 log_debug("Unexpected reply. Ignoring.");
550 m
->missed_replies
= 0;
552 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
553 if (be32toh(ntpmsg
.origin_time
.sec
) != m
->trans_time
.tv_sec
+ OFFSET_1900_1970
||
554 be32toh(ntpmsg
.origin_time
.frac
) != (unsigned long) m
->trans_time
.tv_nsec
) {
555 log_debug("Invalid reply; not our transmit time. Ignoring.");
559 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
561 if (be32toh(ntpmsg
.recv_time
.sec
) < TIME_EPOCH
+ OFFSET_1900_1970
||
562 be32toh(ntpmsg
.trans_time
.sec
) < TIME_EPOCH
+ OFFSET_1900_1970
) {
563 log_debug("Invalid reply, returned times before epoch. Ignoring.");
564 return manager_connect(m
);
567 if (NTP_FIELD_LEAP(ntpmsg
.field
) == NTP_LEAP_NOTINSYNC
||
568 ntpmsg
.stratum
== 0 || ntpmsg
.stratum
>= 16) {
569 log_debug("Server is not synchronized. Disconnecting.");
570 return manager_connect(m
);
573 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg
.field
), 3, 4)) {
574 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg
.field
));
575 return manager_connect(m
);
578 if (NTP_FIELD_MODE(ntpmsg
.field
) != NTP_MODE_SERVER
) {
579 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg
.field
));
580 return manager_connect(m
);
583 root_distance
= ntp_ts_short_to_d(&ntpmsg
.root_delay
) / 2 + ntp_ts_short_to_d(&ntpmsg
.root_dispersion
);
584 if (root_distance
> (double) m
->max_root_distance_usec
/ (double) USEC_PER_SEC
) {
585 log_debug("Server has too large root distance. Disconnecting.");
586 return manager_connect(m
);
591 m
->retry_interval
= 0;
594 manager_listen_stop(m
);
596 /* announce leap seconds */
597 if (NTP_FIELD_LEAP(ntpmsg
.field
) & NTP_LEAP_PLUSSEC
)
599 else if (NTP_FIELD_LEAP(ntpmsg
.field
) & NTP_LEAP_MINUSSEC
)
605 * "Timestamp Name ID When Generated
606 * ------------------------------------------------------------
607 * Originate Timestamp T1 time request sent by client
608 * Receive Timestamp T2 time request received by server
609 * Transmit Timestamp T3 time reply sent by server
610 * Destination Timestamp T4 time reply received by client
612 * The round-trip delay, d, and system clock offset, t, are defined as:
613 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
615 origin
= ts_to_d(&m
->trans_time
) + OFFSET_1900_1970
;
616 receive
= ntp_ts_to_d(&ntpmsg
.recv_time
);
617 trans
= ntp_ts_to_d(&ntpmsg
.trans_time
);
618 dest
= ts_to_d(recv_time
) + OFFSET_1900_1970
;
620 offset
= ((receive
- origin
) + (trans
- dest
)) / 2;
621 delay
= (dest
- origin
) - (trans
- receive
);
623 spike
= manager_sample_spike_detection(m
, offset
, delay
);
625 manager_adjust_poll(m
, offset
, spike
);
627 log_debug("NTP response:\n"
632 " precision : %.6f sec (%d)\n"
633 " root distance: %.6f sec\n"
634 " reference : %.4s\n"
639 " offset : %+.3f sec\n"
640 " delay : %+.3f sec\n"
641 " packet count : %"PRIu64
"\n"
643 " poll interval: " USEC_FMT
"\n",
644 NTP_FIELD_LEAP(ntpmsg
.field
),
645 NTP_FIELD_VERSION(ntpmsg
.field
),
646 NTP_FIELD_MODE(ntpmsg
.field
),
648 exp2(ntpmsg
.precision
), ntpmsg
.precision
,
650 ntpmsg
.stratum
== 1 ? ntpmsg
.refid
: "n/a",
651 origin
- OFFSET_1900_1970
,
652 receive
- OFFSET_1900_1970
,
653 trans
- OFFSET_1900_1970
,
654 dest
- OFFSET_1900_1970
,
657 m
->samples_jitter
, spike
? " spike" : "",
658 m
->poll_interval_usec
/ USEC_PER_SEC
);
662 r
= manager_adjust_clock(m
, offset
, leap_sec
);
664 log_error_errno(r
, "Failed to call clock_adjtime(): %m");
667 log_debug("interval/delta/delay/jitter/drift " USEC_FMT
"s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
668 m
->poll_interval_usec
/ USEC_PER_SEC
, offset
, delay
, m
->samples_jitter
, m
->drift_ppm
,
669 spike
? " (ignored)" : "");
672 _cleanup_free_
char *pretty
= NULL
;
676 server_address_pretty(m
->current_server_address
, &pretty
);
677 log_info("Synchronized to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
678 sd_notifyf(false, "STATUS=Synchronized to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
681 r
= manager_arm_timer(m
, m
->poll_interval_usec
);
683 return log_error_errno(r
, "Failed to rearm timer: %m");
688 static int manager_listen_setup(Manager
*m
) {
689 union sockaddr_union addr
= {};
690 static const int tos
= IPTOS_LOWDELAY
;
691 static const int on
= 1;
696 if (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 (void) 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 void manager_listen_stop(Manager
*m
) {
724 m
->event_receive
= sd_event_source_unref(m
->event_receive
);
725 m
->server_socket
= safe_close(m
->server_socket
);
728 static int manager_begin(Manager
*m
) {
729 _cleanup_free_
char *pretty
= NULL
;
733 assert_return(m
->current_server_name
, -EHOSTUNREACH
);
734 assert_return(m
->current_server_address
, -EHOSTUNREACH
);
737 m
->missed_replies
= NTP_MAX_MISSED_REPLIES
;
738 if (m
->poll_interval_usec
== 0)
739 m
->poll_interval_usec
= m
->poll_interval_min_usec
;
741 server_address_pretty(m
->current_server_address
, &pretty
);
742 log_debug("Connecting to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
743 sd_notifyf(false, "STATUS=Connecting to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
745 r
= manager_clock_watch_setup(m
);
749 return manager_send_request(m
);
752 void manager_set_server_name(Manager
*m
, ServerName
*n
) {
755 if (m
->current_server_name
== n
)
758 m
->current_server_name
= n
;
759 m
->current_server_address
= NULL
;
761 manager_disconnect(m
);
764 log_debug("Selected server %s.", n
->string
);
767 void manager_set_server_address(Manager
*m
, ServerAddress
*a
) {
770 if (m
->current_server_address
== a
)
773 m
->current_server_address
= a
;
774 /* If a is NULL, we are just clearing the address, without
775 * changing the name. Keep the existing name in that case. */
777 m
->current_server_name
= a
->name
;
779 manager_disconnect(m
);
782 _cleanup_free_
char *pretty
= NULL
;
783 server_address_pretty(a
, &pretty
);
784 log_debug("Selected address %s of server %s.", strna(pretty
), a
->name
->string
);
788 static int manager_resolve_handler(sd_resolve_query
*q
, int ret
, const struct addrinfo
*ai
, void *userdata
) {
789 Manager
*m
= userdata
;
794 assert(m
->current_server_name
);
796 m
->resolve_query
= sd_resolve_query_unref(m
->resolve_query
);
799 log_debug("Failed to resolve %s: %s", m
->current_server_name
->string
, gai_strerror(ret
));
802 return manager_connect(m
);
805 for (; ai
; ai
= ai
->ai_next
) {
806 _cleanup_free_
char *pretty
= NULL
;
810 assert(ai
->ai_addrlen
>= offsetof(struct sockaddr
, sa_data
));
812 if (!IN_SET(ai
->ai_addr
->sa_family
, AF_INET
, AF_INET6
)) {
813 log_warning("Unsuitable address protocol for %s", m
->current_server_name
->string
);
817 r
= server_address_new(m
->current_server_name
, &a
, (const union sockaddr_union
*) ai
->ai_addr
, ai
->ai_addrlen
);
819 return log_error_errno(r
, "Failed to add server address: %m");
821 server_address_pretty(a
, &pretty
);
822 log_debug("Resolved address %s for %s.", pretty
, m
->current_server_name
->string
);
825 if (!m
->current_server_name
->addresses
) {
826 log_error("Failed to find suitable address for host %s.", m
->current_server_name
->string
);
829 return manager_connect(m
);
832 manager_set_server_address(m
, m
->current_server_name
->addresses
);
834 return manager_begin(m
);
837 static int manager_retry_connect(sd_event_source
*source
, usec_t usec
, void *userdata
) {
838 Manager
*m
= userdata
;
842 return manager_connect(m
);
845 int manager_connect(Manager
*m
) {
850 manager_disconnect(m
);
852 m
->event_retry
= sd_event_source_unref(m
->event_retry
);
853 if (!ratelimit_test(&m
->ratelimit
)) {
854 log_debug("Slowing down attempts to contact servers.");
856 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
);
858 return log_error_errno(r
, "Failed to create retry timer: %m");
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
);
880 /* Our current server name list is exhausted,
881 * let's find the next one to iterate. First
882 * we try the system list, then the link list.
883 * After having processed the link list we
884 * jump back to the system list. However, if
885 * both lists are empty, we change to the
887 if (!m
->current_server_name
|| m
->current_server_name
->type
== SERVER_LINK
) {
888 f
= m
->system_servers
;
894 f
= m
->system_servers
;
900 f
= m
->fallback_servers
;
903 manager_set_server_name(m
, NULL
);
904 log_debug("No server found.");
908 if (restart
&& !m
->exhausted_servers
&& m
->poll_interval_usec
) {
909 log_debug("Waiting after exhausting servers.");
910 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
);
912 return log_error_errno(r
, "Failed to create retry timer: %m");
914 m
->exhausted_servers
= true;
916 /* Increase the polling interval */
917 if (m
->poll_interval_usec
< m
->poll_interval_max_usec
)
918 m
->poll_interval_usec
*= 2;
923 m
->exhausted_servers
= false;
925 manager_set_server_name(m
, f
);
928 /* Tell the resolver to reread /etc/resolv.conf, in
929 * case it changed. */
932 /* Flush out any previously resolved addresses */
933 server_name_flush_addresses(m
->current_server_name
);
935 log_debug("Resolving %s...", m
->current_server_name
->string
);
937 r
= sd_resolve_getaddrinfo(m
->resolve
, &m
->resolve_query
, m
->current_server_name
->string
, "123", &hints
, manager_resolve_handler
, m
);
939 return log_error_errno(r
, "Failed to create resolver: %m");
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 manager_listen_stop(m
);
960 m
->event_clock_watch
= sd_event_source_unref(m
->event_clock_watch
);
961 m
->clock_watch_fd
= safe_close(m
->clock_watch_fd
);
963 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
965 sd_notifyf(false, "STATUS=Idle.");
968 void manager_flush_server_names(Manager
*m
, ServerType t
) {
971 if (t
== SERVER_SYSTEM
)
972 while (m
->system_servers
)
973 server_name_free(m
->system_servers
);
975 if (t
== SERVER_LINK
)
976 while (m
->link_servers
)
977 server_name_free(m
->link_servers
);
979 if (t
== SERVER_FALLBACK
)
980 while (m
->fallback_servers
)
981 server_name_free(m
->fallback_servers
);
984 void manager_free(Manager
*m
) {
988 manager_disconnect(m
);
989 manager_flush_server_names(m
, SERVER_SYSTEM
);
990 manager_flush_server_names(m
, SERVER_LINK
);
991 manager_flush_server_names(m
, SERVER_FALLBACK
);
993 sd_event_source_unref(m
->event_retry
);
995 sd_event_source_unref(m
->network_event_source
);
996 sd_network_monitor_unref(m
->network_monitor
);
998 sd_resolve_unref(m
->resolve
);
999 sd_event_unref(m
->event
);
1004 static int manager_network_read_link_servers(Manager
*m
) {
1005 _cleanup_strv_free_
char **ntp
= NULL
;
1008 bool changed
= false;
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
);
1039 LIST_FOREACH_SAFE(names
, n
, nx
, m
->link_servers
)
1041 server_name_free(n
);
1048 manager_flush_server_names(m
, SERVER_LINK
);
1052 static int manager_network_event_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
1053 Manager
*m
= userdata
;
1054 bool changed
, connected
, online
;
1059 sd_network_monitor_flush(m
->network_monitor
);
1061 changed
= !!manager_network_read_link_servers(m
);
1063 /* check if the machine is online */
1064 online
= network_is_online();
1066 /* check if the client is currently connected */
1067 connected
= m
->server_socket
>= 0 || m
->resolve_query
|| m
->exhausted_servers
;
1069 if (connected
&& !online
) {
1070 log_info("No network connectivity, watching for changes.");
1071 manager_disconnect(m
);
1073 } else if (!connected
&& online
&& changed
) {
1074 log_info("Network configuration changed, trying to establish connection.");
1076 if (m
->current_server_address
)
1077 r
= manager_begin(m
);
1079 r
= manager_connect(m
);
1087 static int manager_network_monitor_listen(Manager
*m
) {
1092 r
= sd_network_monitor_new(&m
->network_monitor
, NULL
);
1094 log_info("systemd does not appear to be running, not listening for systemd-networkd events.");
1100 fd
= sd_network_monitor_get_fd(m
->network_monitor
);
1104 events
= sd_network_monitor_get_events(m
->network_monitor
);
1108 r
= sd_event_add_io(m
->event
, &m
->network_event_source
, fd
, events
, manager_network_event_handler
, m
);
1115 int manager_new(Manager
**ret
) {
1116 _cleanup_(manager_freep
) Manager
*m
= NULL
;
1121 m
= new0(Manager
, 1);
1125 m
->max_root_distance_usec
= NTP_MAX_ROOT_DISTANCE
;
1126 m
->poll_interval_min_usec
= NTP_POLL_INTERVAL_MIN_USEC
;
1127 m
->poll_interval_max_usec
= NTP_POLL_INTERVAL_MAX_USEC
;
1129 m
->server_socket
= m
->clock_watch_fd
= -1;
1131 RATELIMIT_INIT(m
->ratelimit
, RATELIMIT_INTERVAL_USEC
, RATELIMIT_BURST
);
1133 r
= sd_event_default(&m
->event
);
1137 sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
1138 sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
1140 sd_event_set_watchdog(m
->event
, true);
1142 r
= sd_resolve_default(&m
->resolve
);
1146 r
= sd_resolve_attach_event(m
->resolve
, m
->event
, 0);
1150 r
= manager_network_monitor_listen(m
);
1154 manager_network_read_link_servers(m
);