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
;
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.");
531 CMSG_FOREACH(cmsg
, &msghdr
) {
532 if (cmsg
->cmsg_level
!= SOL_SOCKET
)
535 switch (cmsg
->cmsg_type
) {
536 case SCM_TIMESTAMPNS
:
537 recv_time
= (struct timespec
*) CMSG_DATA(cmsg
);
542 log_error("Invalid packet timestamp.");
547 log_debug("Unexpected reply. Ignoring.");
551 m
->missed_replies
= 0;
553 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
554 if (be32toh(ntpmsg
.origin_time
.sec
) != m
->trans_time
.tv_sec
+ OFFSET_1900_1970
||
555 be32toh(ntpmsg
.origin_time
.frac
) != m
->trans_time
.tv_nsec
) {
556 log_debug("Invalid reply; not our transmit time. Ignoring.");
560 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
562 if (be32toh(ntpmsg
.recv_time
.sec
) < TIME_EPOCH
+ OFFSET_1900_1970
||
563 be32toh(ntpmsg
.trans_time
.sec
) < TIME_EPOCH
+ OFFSET_1900_1970
) {
564 log_debug("Invalid reply, returned times before epoch. Ignoring.");
565 return manager_connect(m
);
568 if (NTP_FIELD_LEAP(ntpmsg
.field
) == NTP_LEAP_NOTINSYNC
||
569 ntpmsg
.stratum
== 0 || ntpmsg
.stratum
>= 16) {
570 log_debug("Server is not synchronized. Disconnecting.");
571 return manager_connect(m
);
574 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg
.field
), 3, 4)) {
575 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg
.field
));
576 return manager_connect(m
);
579 if (NTP_FIELD_MODE(ntpmsg
.field
) != NTP_MODE_SERVER
) {
580 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg
.field
));
581 return manager_connect(m
);
584 root_distance
= ntp_ts_short_to_d(&ntpmsg
.root_delay
) / 2 + ntp_ts_short_to_d(&ntpmsg
.root_dispersion
);
585 if (root_distance
> (double) m
->max_root_distance_usec
/ (double) USEC_PER_SEC
) {
586 log_debug("Server has too large root distance. Disconnecting.");
587 return manager_connect(m
);
592 m
->retry_interval
= 0;
595 manager_listen_stop(m
);
597 /* announce leap seconds */
598 if (NTP_FIELD_LEAP(ntpmsg
.field
) & NTP_LEAP_PLUSSEC
)
600 else if (NTP_FIELD_LEAP(ntpmsg
.field
) & NTP_LEAP_MINUSSEC
)
606 * "Timestamp Name ID When Generated
607 * ------------------------------------------------------------
608 * Originate Timestamp T1 time request sent by client
609 * Receive Timestamp T2 time request received by server
610 * Transmit Timestamp T3 time reply sent by server
611 * Destination Timestamp T4 time reply received by client
613 * The round-trip delay, d, and system clock offset, t, are defined as:
614 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
616 origin
= ts_to_d(&m
->trans_time
) + OFFSET_1900_1970
;
617 receive
= ntp_ts_to_d(&ntpmsg
.recv_time
);
618 trans
= ntp_ts_to_d(&ntpmsg
.trans_time
);
619 dest
= ts_to_d(recv_time
) + OFFSET_1900_1970
;
621 offset
= ((receive
- origin
) + (trans
- dest
)) / 2;
622 delay
= (dest
- origin
) - (trans
- receive
);
624 spike
= manager_sample_spike_detection(m
, offset
, delay
);
626 manager_adjust_poll(m
, offset
, spike
);
628 log_debug("NTP response:\n"
633 " precision : %.6f sec (%d)\n"
634 " root distance: %.6f sec\n"
635 " reference : %.4s\n"
640 " offset : %+.3f sec\n"
641 " delay : %+.3f sec\n"
642 " packet count : %"PRIu64
"\n"
644 " poll interval: " USEC_FMT
"\n",
645 NTP_FIELD_LEAP(ntpmsg
.field
),
646 NTP_FIELD_VERSION(ntpmsg
.field
),
647 NTP_FIELD_MODE(ntpmsg
.field
),
649 exp2(ntpmsg
.precision
), ntpmsg
.precision
,
651 ntpmsg
.stratum
== 1 ? ntpmsg
.refid
: "n/a",
652 origin
- OFFSET_1900_1970
,
653 receive
- OFFSET_1900_1970
,
654 trans
- OFFSET_1900_1970
,
655 dest
- OFFSET_1900_1970
,
658 m
->samples_jitter
, spike
? " spike" : "",
659 m
->poll_interval_usec
/ USEC_PER_SEC
);
663 r
= manager_adjust_clock(m
, offset
, leap_sec
);
665 log_error_errno(r
, "Failed to call clock_adjtime(): %m");
668 log_debug("interval/delta/delay/jitter/drift " USEC_FMT
"s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
669 m
->poll_interval_usec
/ USEC_PER_SEC
, offset
, delay
, m
->samples_jitter
, m
->drift_ppm
,
670 spike
? " (ignored)" : "");
673 _cleanup_free_
char *pretty
= NULL
;
677 server_address_pretty(m
->current_server_address
, &pretty
);
678 log_info("Synchronized to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
679 sd_notifyf(false, "STATUS=Synchronized to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
682 r
= manager_arm_timer(m
, m
->poll_interval_usec
);
684 return log_error_errno(r
, "Failed to rearm timer: %m");
689 static int manager_listen_setup(Manager
*m
) {
690 union sockaddr_union addr
= {};
691 static const int tos
= IPTOS_LOWDELAY
;
692 static const int on
= 1;
697 if (m
->server_socket
>= 0)
700 assert(!m
->event_receive
);
701 assert(m
->current_server_address
);
703 addr
.sa
.sa_family
= m
->current_server_address
->sockaddr
.sa
.sa_family
;
705 m
->server_socket
= socket(addr
.sa
.sa_family
, SOCK_DGRAM
| SOCK_CLOEXEC
, 0);
706 if (m
->server_socket
< 0)
709 r
= bind(m
->server_socket
, &addr
.sa
, m
->current_server_address
->socklen
);
713 r
= setsockopt(m
->server_socket
, SOL_SOCKET
, SO_TIMESTAMPNS
, &on
, sizeof(on
));
717 (void) setsockopt(m
->server_socket
, IPPROTO_IP
, IP_TOS
, &tos
, sizeof(tos
));
719 return sd_event_add_io(m
->event
, &m
->event_receive
, m
->server_socket
, EPOLLIN
, manager_receive_response
, m
);
722 static void manager_listen_stop(Manager
*m
) {
725 m
->event_receive
= sd_event_source_unref(m
->event_receive
);
726 m
->server_socket
= safe_close(m
->server_socket
);
729 static int manager_begin(Manager
*m
) {
730 _cleanup_free_
char *pretty
= NULL
;
734 assert_return(m
->current_server_name
, -EHOSTUNREACH
);
735 assert_return(m
->current_server_address
, -EHOSTUNREACH
);
738 m
->missed_replies
= NTP_MAX_MISSED_REPLIES
;
739 if (m
->poll_interval_usec
== 0)
740 m
->poll_interval_usec
= m
->poll_interval_min_usec
;
742 server_address_pretty(m
->current_server_address
, &pretty
);
743 log_debug("Connecting to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
744 sd_notifyf(false, "STATUS=Connecting to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
746 r
= manager_clock_watch_setup(m
);
750 return manager_send_request(m
);
753 void manager_set_server_name(Manager
*m
, ServerName
*n
) {
756 if (m
->current_server_name
== n
)
759 m
->current_server_name
= n
;
760 m
->current_server_address
= NULL
;
762 manager_disconnect(m
);
765 log_debug("Selected server %s.", n
->string
);
768 void manager_set_server_address(Manager
*m
, ServerAddress
*a
) {
771 if (m
->current_server_address
== a
)
774 m
->current_server_address
= a
;
775 /* If a is NULL, we are just clearing the address, without
776 * changing the name. Keep the existing name in that case. */
778 m
->current_server_name
= a
->name
;
780 manager_disconnect(m
);
783 _cleanup_free_
char *pretty
= NULL
;
784 server_address_pretty(a
, &pretty
);
785 log_debug("Selected address %s of server %s.", strna(pretty
), a
->name
->string
);
789 static int manager_resolve_handler(sd_resolve_query
*q
, int ret
, const struct addrinfo
*ai
, void *userdata
) {
790 Manager
*m
= userdata
;
795 assert(m
->current_server_name
);
797 m
->resolve_query
= sd_resolve_query_unref(m
->resolve_query
);
800 log_debug("Failed to resolve %s: %s", m
->current_server_name
->string
, gai_strerror(ret
));
803 return manager_connect(m
);
806 for (; ai
; ai
= ai
->ai_next
) {
807 _cleanup_free_
char *pretty
= NULL
;
811 assert(ai
->ai_addrlen
>= offsetof(struct sockaddr
, sa_data
));
813 if (!IN_SET(ai
->ai_addr
->sa_family
, AF_INET
, AF_INET6
)) {
814 log_warning("Unsuitable address protocol for %s", m
->current_server_name
->string
);
818 r
= server_address_new(m
->current_server_name
, &a
, (const union sockaddr_union
*) ai
->ai_addr
, ai
->ai_addrlen
);
820 return log_error_errno(r
, "Failed to add server address: %m");
822 server_address_pretty(a
, &pretty
);
823 log_debug("Resolved address %s for %s.", pretty
, m
->current_server_name
->string
);
826 if (!m
->current_server_name
->addresses
) {
827 log_error("Failed to find suitable address for host %s.", m
->current_server_name
->string
);
830 return manager_connect(m
);
833 manager_set_server_address(m
, m
->current_server_name
->addresses
);
835 return manager_begin(m
);
838 static int manager_retry_connect(sd_event_source
*source
, usec_t usec
, void *userdata
) {
839 Manager
*m
= userdata
;
843 return manager_connect(m
);
846 int manager_connect(Manager
*m
) {
851 manager_disconnect(m
);
853 m
->event_retry
= sd_event_source_unref(m
->event_retry
);
854 if (!ratelimit_test(&m
->ratelimit
)) {
855 log_debug("Slowing down attempts to contact servers.");
857 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
);
859 return log_error_errno(r
, "Failed to create retry timer: %m");
864 /* If we already are operating on some address, switch to the
866 if (m
->current_server_address
&& m
->current_server_address
->addresses_next
)
867 manager_set_server_address(m
, m
->current_server_address
->addresses_next
);
869 struct addrinfo hints
= {
870 .ai_flags
= AI_NUMERICSERV
|AI_ADDRCONFIG
,
871 .ai_socktype
= SOCK_DGRAM
,
874 /* Hmm, we are through all addresses, let's look for the next host instead */
875 if (m
->current_server_name
&& m
->current_server_name
->names_next
)
876 manager_set_server_name(m
, m
->current_server_name
->names_next
);
881 /* Our current server name list is exhausted,
882 * let's find the next one to iterate. First
883 * we try the system list, then the link list.
884 * After having processed the link list we
885 * jump back to the system list. However, if
886 * both lists are empty, we change to the
888 if (!m
->current_server_name
|| m
->current_server_name
->type
== SERVER_LINK
) {
889 f
= m
->system_servers
;
895 f
= m
->system_servers
;
901 f
= m
->fallback_servers
;
904 manager_set_server_name(m
, NULL
);
905 log_debug("No server found.");
909 if (restart
&& !m
->exhausted_servers
&& m
->poll_interval_usec
) {
910 log_debug("Waiting after exhausting servers.");
911 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
);
913 return log_error_errno(r
, "Failed to create retry timer: %m");
915 m
->exhausted_servers
= true;
917 /* Increase the polling interval */
918 if (m
->poll_interval_usec
< m
->poll_interval_max_usec
)
919 m
->poll_interval_usec
*= 2;
924 m
->exhausted_servers
= false;
926 manager_set_server_name(m
, f
);
929 /* Tell the resolver to reread /etc/resolv.conf, in
930 * case it changed. */
933 /* Flush out any previously resolved addresses */
934 server_name_flush_addresses(m
->current_server_name
);
936 log_debug("Resolving %s...", m
->current_server_name
->string
);
938 r
= sd_resolve_getaddrinfo(m
->resolve
, &m
->resolve_query
, m
->current_server_name
->string
, "123", &hints
, manager_resolve_handler
, m
);
940 return log_error_errno(r
, "Failed to create resolver: %m");
945 r
= manager_begin(m
);
952 void manager_disconnect(Manager
*m
) {
955 m
->resolve_query
= sd_resolve_query_unref(m
->resolve_query
);
957 m
->event_timer
= sd_event_source_unref(m
->event_timer
);
959 manager_listen_stop(m
);
961 m
->event_clock_watch
= sd_event_source_unref(m
->event_clock_watch
);
962 m
->clock_watch_fd
= safe_close(m
->clock_watch_fd
);
964 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
966 sd_notifyf(false, "STATUS=Idle.");
969 void manager_flush_server_names(Manager
*m
, ServerType t
) {
972 if (t
== SERVER_SYSTEM
)
973 while (m
->system_servers
)
974 server_name_free(m
->system_servers
);
976 if (t
== SERVER_LINK
)
977 while (m
->link_servers
)
978 server_name_free(m
->link_servers
);
980 if (t
== SERVER_FALLBACK
)
981 while (m
->fallback_servers
)
982 server_name_free(m
->fallback_servers
);
985 void manager_free(Manager
*m
) {
989 manager_disconnect(m
);
990 manager_flush_server_names(m
, SERVER_SYSTEM
);
991 manager_flush_server_names(m
, SERVER_LINK
);
992 manager_flush_server_names(m
, SERVER_FALLBACK
);
994 sd_event_source_unref(m
->event_retry
);
996 sd_event_source_unref(m
->network_event_source
);
997 sd_network_monitor_unref(m
->network_monitor
);
999 sd_resolve_unref(m
->resolve
);
1000 sd_event_unref(m
->event
);
1005 static int manager_network_read_link_servers(Manager
*m
) {
1006 _cleanup_strv_free_
char **ntp
= NULL
;
1013 r
= sd_network_get_ntp(&ntp
);
1017 LIST_FOREACH(names
, n
, m
->link_servers
)
1020 STRV_FOREACH(i
, ntp
) {
1023 LIST_FOREACH(names
, n
, m
->link_servers
)
1024 if (streq(n
->string
, *i
)) {
1031 r
= server_name_new(m
, NULL
, SERVER_LINK
, *i
);
1037 LIST_FOREACH_SAFE(names
, n
, nx
, m
->link_servers
)
1039 server_name_free(n
);
1044 manager_flush_server_names(m
, SERVER_LINK
);
1048 static int manager_network_event_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
1049 Manager
*m
= userdata
;
1050 bool connected
, online
;
1055 sd_network_monitor_flush(m
->network_monitor
);
1057 manager_network_read_link_servers(m
);
1059 /* check if the machine is online */
1060 online
= network_is_online();
1062 /* check if the client is currently connected */
1063 connected
= m
->server_socket
>= 0 || m
->resolve_query
|| m
->exhausted_servers
;
1065 if (connected
&& !online
) {
1066 log_info("No network connectivity, watching for changes.");
1067 manager_disconnect(m
);
1069 } else if (!connected
&& online
) {
1070 log_info("Network configuration changed, trying to establish connection.");
1072 if (m
->current_server_address
)
1073 r
= manager_begin(m
);
1075 r
= manager_connect(m
);
1083 static int manager_network_monitor_listen(Manager
*m
) {
1088 r
= sd_network_monitor_new(&m
->network_monitor
, NULL
);
1090 log_info("systemd does not appear to be running, not listening for systemd-networkd events.");
1096 fd
= sd_network_monitor_get_fd(m
->network_monitor
);
1100 events
= sd_network_monitor_get_events(m
->network_monitor
);
1104 r
= sd_event_add_io(m
->event
, &m
->network_event_source
, fd
, events
, manager_network_event_handler
, m
);
1111 int manager_new(Manager
**ret
) {
1112 _cleanup_(manager_freep
) Manager
*m
= NULL
;
1117 m
= new0(Manager
, 1);
1121 m
->max_root_distance_usec
= NTP_MAX_ROOT_DISTANCE
;
1122 m
->poll_interval_min_usec
= NTP_POLL_INTERVAL_MIN_USEC
;
1123 m
->poll_interval_max_usec
= NTP_POLL_INTERVAL_MAX_USEC
;
1125 m
->server_socket
= m
->clock_watch_fd
= -1;
1127 RATELIMIT_INIT(m
->ratelimit
, RATELIMIT_INTERVAL_USEC
, RATELIMIT_BURST
);
1129 r
= sd_event_default(&m
->event
);
1133 sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
1134 sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
1136 sd_event_set_watchdog(m
->event
, true);
1138 r
= sd_resolve_default(&m
->resolve
);
1142 r
= sd_resolve_attach_event(m
->resolve
, m
->event
, 0);
1146 r
= manager_network_monitor_listen(m
);
1150 manager_network_read_link_servers(m
);