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/>.
24 #include <netinet/in.h>
25 #include <netinet/ip.h>
28 #include <sys/socket.h>
29 #include <sys/timerfd.h>
30 #include <sys/timex.h>
31 #include <sys/types.h>
34 #include "sd-daemon.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 * "A client MUST NOT under any conditions use a poll interval less
63 #define NTP_POLL_INTERVAL_MIN_SEC 32
64 #define NTP_POLL_INTERVAL_MAX_SEC 2048
67 * Maximum delta in seconds which the system clock is gradually adjusted
68 * (slew) to approach the network time. Deltas larger that this are set by
69 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
71 #define NTP_MAX_ADJUST 0.4
73 /* NTP protocol, packet header */
74 #define NTP_LEAP_PLUSSEC 1
75 #define NTP_LEAP_MINUSSEC 2
76 #define NTP_LEAP_NOTINSYNC 3
77 #define NTP_MODE_CLIENT 3
78 #define NTP_MODE_SERVER 4
79 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
80 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
81 #define NTP_FIELD_MODE(f) ((f) & 7)
82 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
84 /* Maximum acceptable root distance in seconds. */
85 #define NTP_MAX_ROOT_DISTANCE 5.0
87 /* Maximum number of missed replies before selecting another source. */
88 #define NTP_MAX_MISSED_REPLIES 2
91 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
92 * in seconds relative to 0h on 1 January 1900."
94 #define OFFSET_1900_1970 UINT64_C(2208988800)
96 #define RETRY_USEC (30*USEC_PER_SEC)
97 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
98 #define RATELIMIT_BURST 10
100 #define TIMEOUT_USEC (10*USEC_PER_SEC)
107 struct ntp_ts_short
{
117 struct ntp_ts_short root_delay
;
118 struct ntp_ts_short root_dispersion
;
120 struct ntp_ts reference_time
;
121 struct ntp_ts origin_time
;
122 struct ntp_ts recv_time
;
123 struct ntp_ts trans_time
;
126 static int manager_arm_timer(Manager
*m
, usec_t next
);
127 static int manager_clock_watch_setup(Manager
*m
);
128 static int manager_listen_setup(Manager
*m
);
129 static void manager_listen_stop(Manager
*m
);
131 static double ntp_ts_short_to_d(const struct ntp_ts_short
*ts
) {
132 return be16toh(ts
->sec
) + (be16toh(ts
->frac
) / 65536.0);
135 static double ntp_ts_to_d(const struct ntp_ts
*ts
) {
136 return be32toh(ts
->sec
) + ((double)be32toh(ts
->frac
) / UINT_MAX
);
139 static double ts_to_d(const struct timespec
*ts
) {
140 return ts
->tv_sec
+ (1.0e-9 * ts
->tv_nsec
);
143 static int manager_timeout(sd_event_source
*source
, usec_t usec
, void *userdata
) {
144 _cleanup_free_
char *pretty
= NULL
;
145 Manager
*m
= userdata
;
148 assert(m
->current_server_name
);
149 assert(m
->current_server_address
);
151 server_address_pretty(m
->current_server_address
, &pretty
);
152 log_info("Timed out waiting for reply from %s (%s).", strna(pretty
), m
->current_server_name
->string
);
154 return manager_connect(m
);
157 static int manager_send_request(Manager
*m
) {
158 _cleanup_free_
char *pretty
= NULL
;
159 struct ntp_msg ntpmsg
= {
161 * "The client initializes the NTP message header, sends the request
162 * to the server, and strips the time of day from the Transmit
163 * Timestamp field of the reply. For this purpose, all the NTP
164 * header fields are set to 0, except the Mode, VN, and optional
165 * Transmit Timestamp fields."
167 .field
= NTP_FIELD(0, 4, NTP_MODE_CLIENT
),
173 assert(m
->current_server_name
);
174 assert(m
->current_server_address
);
176 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
178 r
= manager_listen_setup(m
);
180 return log_warning_errno(r
, "Failed to setup connection socket: %m");
183 * Set transmit timestamp, remember it; the server will send that back
184 * as the origin timestamp and we have an indication that this is the
185 * matching answer to our request.
187 * The actual value does not matter, We do not care about the correct
188 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
190 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m
->trans_time_mon
) >= 0);
191 assert_se(clock_gettime(CLOCK_REALTIME
, &m
->trans_time
) >= 0);
192 ntpmsg
.trans_time
.sec
= htobe32(m
->trans_time
.tv_sec
+ OFFSET_1900_1970
);
193 ntpmsg
.trans_time
.frac
= htobe32(m
->trans_time
.tv_nsec
);
195 server_address_pretty(m
->current_server_address
, &pretty
);
197 len
= sendto(m
->server_socket
, &ntpmsg
, sizeof(ntpmsg
), MSG_DONTWAIT
, &m
->current_server_address
->sockaddr
.sa
, m
->current_server_address
->socklen
);
198 if (len
== sizeof(ntpmsg
)) {
200 log_debug("Sent NTP request to %s (%s).", strna(pretty
), m
->current_server_name
->string
);
202 log_debug_errno(errno
, "Sending NTP request to %s (%s) failed: %m", strna(pretty
), m
->current_server_name
->string
);
203 return manager_connect(m
);
206 /* re-arm timer with increasing timeout, in case the packets never arrive back */
207 if (m
->retry_interval
> 0) {
208 if (m
->retry_interval
< NTP_POLL_INTERVAL_MAX_SEC
* USEC_PER_SEC
)
209 m
->retry_interval
*= 2;
211 m
->retry_interval
= NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
;
213 r
= manager_arm_timer(m
, m
->retry_interval
);
215 return log_error_errno(r
, "Failed to rearm timer: %m");
218 if (m
->missed_replies
> NTP_MAX_MISSED_REPLIES
) {
219 r
= sd_event_add_time(
222 clock_boottime_or_monotonic(),
223 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC
, 0,
226 return log_error_errno(r
, "Failed to arm timeout timer: %m");
232 static int manager_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
233 Manager
*m
= userdata
;
237 return manager_send_request(m
);
240 static int manager_arm_timer(Manager
*m
, usec_t next
) {
246 m
->event_timer
= sd_event_source_unref(m
->event_timer
);
250 if (m
->event_timer
) {
251 r
= sd_event_source_set_time(m
->event_timer
, now(clock_boottime_or_monotonic()) + next
);
255 return sd_event_source_set_enabled(m
->event_timer
, SD_EVENT_ONESHOT
);
258 return sd_event_add_time(
261 clock_boottime_or_monotonic(),
262 now(clock_boottime_or_monotonic()) + next
, 0,
266 static int manager_clock_watch(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
267 Manager
*m
= userdata
;
272 manager_clock_watch_setup(m
);
274 /* skip our own jumps */
281 log_debug("System time changed. Resyncing.");
282 m
->poll_resync
= true;
284 return manager_send_request(m
);
287 /* wake up when the system time changes underneath us */
288 static int manager_clock_watch_setup(Manager
*m
) {
290 struct itimerspec its
= {
291 .it_value
.tv_sec
= TIME_T_MAX
298 m
->event_clock_watch
= sd_event_source_unref(m
->event_clock_watch
);
299 safe_close(m
->clock_watch_fd
);
301 m
->clock_watch_fd
= timerfd_create(CLOCK_REALTIME
, TFD_NONBLOCK
|TFD_CLOEXEC
);
302 if (m
->clock_watch_fd
< 0)
303 return log_error_errno(errno
, "Failed to create timerfd: %m");
305 if (timerfd_settime(m
->clock_watch_fd
, TFD_TIMER_ABSTIME
|TFD_TIMER_CANCEL_ON_SET
, &its
, NULL
) < 0)
306 return log_error_errno(errno
, "Failed to set up timerfd: %m");
308 r
= sd_event_add_io(m
->event
, &m
->event_clock_watch
, m
->clock_watch_fd
, EPOLLIN
, manager_clock_watch
, m
);
310 return log_error_errno(r
, "Failed to create clock watch event source: %m");
315 static int manager_adjust_clock(Manager
*m
, double offset
, int leap_sec
) {
316 struct timex tmx
= {};
322 * For small deltas, tell the kernel to gradually adjust the system
323 * clock to the NTP time, larger deltas are just directly set.
325 if (fabs(offset
) < NTP_MAX_ADJUST
) {
326 tmx
.modes
= ADJ_STATUS
| ADJ_NANO
| ADJ_OFFSET
| ADJ_TIMECONST
| ADJ_MAXERROR
| ADJ_ESTERROR
;
327 tmx
.status
= STA_PLL
;
328 tmx
.offset
= offset
* NSEC_PER_SEC
;
329 tmx
.constant
= log2i(m
->poll_interval_usec
/ USEC_PER_SEC
) - 4;
332 log_debug(" adjust (slew): %+.3f sec", offset
);
334 tmx
.modes
= ADJ_STATUS
| ADJ_NANO
| ADJ_SETOFFSET
;
336 /* ADJ_NANO uses nanoseconds in the microseconds field */
337 tmx
.time
.tv_sec
= (long)offset
;
338 tmx
.time
.tv_usec
= (offset
- tmx
.time
.tv_sec
) * NSEC_PER_SEC
;
340 /* the kernel expects -0.3s as {-1, 7000.000.000} */
341 if (tmx
.time
.tv_usec
< 0) {
342 tmx
.time
.tv_sec
-= 1;
343 tmx
.time
.tv_usec
+= NSEC_PER_SEC
;
347 log_debug(" adjust (jump): %+.3f sec", offset
);
351 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
352 * which syncs the system time periodically to the RTC.
354 * In case the RTC runs in local time, never touch the RTC,
355 * we have no way to properly handle daylight saving changes and
356 * mobile devices moving between time zones.
358 if (m
->rtc_local_time
)
359 tmx
.status
|= STA_UNSYNC
;
363 tmx
.status
|= STA_INS
;
366 tmx
.status
|= STA_DEL
;
370 r
= clock_adjtime(CLOCK_REALTIME
, &tmx
);
374 touch("/var/lib/systemd/clock");
376 m
->drift_ppm
= tmx
.freq
/ 65536;
378 log_debug(" status : %04i %s\n"
379 " time now : %li.%03llu\n"
381 " offset : %+.3f sec\n"
382 " freq offset : %+li (%i ppm)\n",
383 tmx
.status
, tmx
.status
& STA_UNSYNC
? "unsync" : "sync",
384 tmx
.time
.tv_sec
, (unsigned long long) (tmx
.time
.tv_usec
/ NSEC_PER_MSEC
),
386 (double)tmx
.offset
/ NSEC_PER_SEC
,
387 tmx
.freq
, m
->drift_ppm
);
392 static bool manager_sample_spike_detection(Manager
*m
, double offset
, double delay
) {
393 unsigned int i
, idx_cur
, idx_new
, idx_min
;
401 /* ignore initial sample */
402 if (m
->packet_count
== 1)
405 /* store the current data in our samples array */
406 idx_cur
= m
->samples_idx
;
407 idx_new
= (idx_cur
+ 1) % ELEMENTSOF(m
->samples
);
408 m
->samples_idx
= idx_new
;
409 m
->samples
[idx_new
].offset
= offset
;
410 m
->samples
[idx_new
].delay
= delay
;
412 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
413 jitter
= m
->samples_jitter
;
414 for (idx_min
= idx_cur
, i
= 0; i
< ELEMENTSOF(m
->samples
); i
++)
415 if (m
->samples
[i
].delay
> 0 && m
->samples
[i
].delay
< m
->samples
[idx_min
].delay
)
419 for (i
= 0; i
< ELEMENTSOF(m
->samples
); i
++)
420 j
+= pow(m
->samples
[i
].offset
- m
->samples
[idx_min
].offset
, 2);
421 m
->samples_jitter
= sqrt(j
/ (ELEMENTSOF(m
->samples
) - 1));
423 /* ignore samples when resyncing */
427 /* always accept offset if we are farther off than the round-trip delay */
428 if (fabs(offset
) > delay
)
431 /* we need a few samples before looking at them */
432 if (m
->packet_count
< 4)
435 /* do not accept anything worse than the maximum possible error of the best sample */
436 if (fabs(offset
) > m
->samples
[idx_min
].delay
)
439 /* compare the difference between the current offset to the previous offset and jitter */
440 return fabs(offset
- m
->samples
[idx_cur
].offset
) > 3 * jitter
;
443 static void manager_adjust_poll(Manager
*m
, double offset
, bool spike
) {
446 if (m
->poll_resync
) {
447 m
->poll_interval_usec
= NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
;
448 m
->poll_resync
= false;
452 /* set to minimal poll interval */
453 if (!spike
&& fabs(offset
) > NTP_ACCURACY_SEC
) {
454 m
->poll_interval_usec
= NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
;
458 /* increase polling interval */
459 if (fabs(offset
) < NTP_ACCURACY_SEC
* 0.25) {
460 if (m
->poll_interval_usec
< NTP_POLL_INTERVAL_MAX_SEC
* USEC_PER_SEC
)
461 m
->poll_interval_usec
*= 2;
465 /* decrease polling interval */
466 if (spike
|| fabs(offset
) > NTP_ACCURACY_SEC
* 0.75) {
467 if (m
->poll_interval_usec
> NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
)
468 m
->poll_interval_usec
/= 2;
473 static int manager_receive_response(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
474 Manager
*m
= userdata
;
475 struct ntp_msg ntpmsg
;
479 .iov_len
= sizeof(ntpmsg
),
482 struct cmsghdr cmsghdr
;
483 uint8_t buf
[CMSG_SPACE(sizeof(struct timeval
))];
485 union sockaddr_union server_addr
;
486 struct msghdr msghdr
= {
489 .msg_control
= &control
,
490 .msg_controllen
= sizeof(control
),
491 .msg_name
= &server_addr
,
492 .msg_namelen
= sizeof(server_addr
),
494 struct cmsghdr
*cmsg
;
495 struct timespec
*recv_time
;
497 double origin
, receive
, trans
, dest
;
498 double delay
, offset
;
499 double root_distance
;
507 if (revents
& (EPOLLHUP
|EPOLLERR
)) {
508 log_warning("Server connection returned error.");
509 return manager_connect(m
);
512 len
= recvmsg(fd
, &msghdr
, MSG_DONTWAIT
);
517 log_warning("Error receiving message. Disconnecting.");
518 return manager_connect(m
);
521 /* Too short or too long packet? */
522 if (iov
.iov_len
< sizeof(struct ntp_msg
) || (msghdr
.msg_flags
& MSG_TRUNC
)) {
523 log_warning("Invalid response from server. Disconnecting.");
524 return manager_connect(m
);
527 if (!m
->current_server_name
||
528 !m
->current_server_address
||
529 !sockaddr_equal(&server_addr
, &m
->current_server_address
->sockaddr
)) {
530 log_debug("Response from unknown server.");
535 CMSG_FOREACH(cmsg
, &msghdr
) {
536 if (cmsg
->cmsg_level
!= SOL_SOCKET
)
539 switch (cmsg
->cmsg_type
) {
540 case SCM_TIMESTAMPNS
:
541 recv_time
= (struct timespec
*) CMSG_DATA(cmsg
);
546 log_error("Invalid packet timestamp.");
551 log_debug("Unexpected reply. Ignoring.");
555 m
->missed_replies
= 0;
557 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
558 if (be32toh(ntpmsg
.origin_time
.sec
) != m
->trans_time
.tv_sec
+ OFFSET_1900_1970
||
559 be32toh(ntpmsg
.origin_time
.frac
) != m
->trans_time
.tv_nsec
) {
560 log_debug("Invalid reply; not our transmit time. Ignoring.");
564 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
566 if (be32toh(ntpmsg
.recv_time
.sec
) < TIME_EPOCH
+ OFFSET_1900_1970
||
567 be32toh(ntpmsg
.trans_time
.sec
) < TIME_EPOCH
+ OFFSET_1900_1970
) {
568 log_debug("Invalid reply, returned times before epoch. Ignoring.");
569 return manager_connect(m
);
572 if (NTP_FIELD_LEAP(ntpmsg
.field
) == NTP_LEAP_NOTINSYNC
||
573 ntpmsg
.stratum
== 0 || ntpmsg
.stratum
>= 16) {
574 log_debug("Server is not synchronized. Disconnecting.");
575 return manager_connect(m
);
578 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg
.field
), 3, 4)) {
579 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg
.field
));
580 return manager_connect(m
);
583 if (NTP_FIELD_MODE(ntpmsg
.field
) != NTP_MODE_SERVER
) {
584 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg
.field
));
585 return manager_connect(m
);
588 root_distance
= ntp_ts_short_to_d(&ntpmsg
.root_delay
) / 2 + ntp_ts_short_to_d(&ntpmsg
.root_dispersion
);
589 if (root_distance
> NTP_MAX_ROOT_DISTANCE
) {
590 log_debug("Server has too large root distance. Disconnecting.");
591 return manager_connect(m
);
596 m
->retry_interval
= 0;
599 manager_listen_stop(m
);
601 /* announce leap seconds */
602 if (NTP_FIELD_LEAP(ntpmsg
.field
) & NTP_LEAP_PLUSSEC
)
604 else if (NTP_FIELD_LEAP(ntpmsg
.field
) & NTP_LEAP_MINUSSEC
)
610 * "Timestamp Name ID When Generated
611 * ------------------------------------------------------------
612 * Originate Timestamp T1 time request sent by client
613 * Receive Timestamp T2 time request received by server
614 * Transmit Timestamp T3 time reply sent by server
615 * Destination Timestamp T4 time reply received by client
617 * The round-trip delay, d, and system clock offset, t, are defined as:
618 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
620 origin
= ts_to_d(&m
->trans_time
) + OFFSET_1900_1970
;
621 receive
= ntp_ts_to_d(&ntpmsg
.recv_time
);
622 trans
= ntp_ts_to_d(&ntpmsg
.trans_time
);
623 dest
= ts_to_d(recv_time
) + OFFSET_1900_1970
;
625 offset
= ((receive
- origin
) + (trans
- dest
)) / 2;
626 delay
= (dest
- origin
) - (trans
- receive
);
628 spike
= manager_sample_spike_detection(m
, offset
, delay
);
630 manager_adjust_poll(m
, offset
, spike
);
632 log_debug("NTP response:\n"
637 " precision : %.6f sec (%d)\n"
638 " root distance: %.6f sec\n"
639 " reference : %.4s\n"
644 " offset : %+.3f sec\n"
645 " delay : %+.3f sec\n"
646 " packet count : %"PRIu64
"\n"
648 " poll interval: " USEC_FMT
"\n",
649 NTP_FIELD_LEAP(ntpmsg
.field
),
650 NTP_FIELD_VERSION(ntpmsg
.field
),
651 NTP_FIELD_MODE(ntpmsg
.field
),
653 exp2(ntpmsg
.precision
), ntpmsg
.precision
,
655 ntpmsg
.stratum
== 1 ? ntpmsg
.refid
: "n/a",
656 origin
- OFFSET_1900_1970
,
657 receive
- OFFSET_1900_1970
,
658 trans
- OFFSET_1900_1970
,
659 dest
- OFFSET_1900_1970
,
662 m
->samples_jitter
, spike
? " spike" : "",
663 m
->poll_interval_usec
/ USEC_PER_SEC
);
667 r
= manager_adjust_clock(m
, offset
, leap_sec
);
669 log_error_errno(errno
, "Failed to call clock_adjtime(): %m");
672 log_debug("interval/delta/delay/jitter/drift " USEC_FMT
"s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
673 m
->poll_interval_usec
/ USEC_PER_SEC
, offset
, delay
, m
->samples_jitter
, m
->drift_ppm
,
674 spike
? " (ignored)" : "");
677 _cleanup_free_
char *pretty
= NULL
;
681 server_address_pretty(m
->current_server_address
, &pretty
);
682 log_info("Synchronized to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
683 sd_notifyf(false, "STATUS=Synchronized to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
686 r
= manager_arm_timer(m
, m
->poll_interval_usec
);
688 return log_error_errno(r
, "Failed to rearm timer: %m");
693 static int manager_listen_setup(Manager
*m
) {
694 union sockaddr_union addr
= {};
695 static const int tos
= IPTOS_LOWDELAY
;
696 static const int on
= 1;
701 if (m
->server_socket
>= 0)
704 assert(!m
->event_receive
);
705 assert(m
->current_server_address
);
707 addr
.sa
.sa_family
= m
->current_server_address
->sockaddr
.sa
.sa_family
;
709 m
->server_socket
= socket(addr
.sa
.sa_family
, SOCK_DGRAM
| SOCK_CLOEXEC
, 0);
710 if (m
->server_socket
< 0)
713 r
= bind(m
->server_socket
, &addr
.sa
, m
->current_server_address
->socklen
);
717 r
= setsockopt(m
->server_socket
, SOL_SOCKET
, SO_TIMESTAMPNS
, &on
, sizeof(on
));
721 (void) setsockopt(m
->server_socket
, IPPROTO_IP
, IP_TOS
, &tos
, sizeof(tos
));
723 return sd_event_add_io(m
->event
, &m
->event_receive
, m
->server_socket
, EPOLLIN
, manager_receive_response
, m
);
726 static void manager_listen_stop(Manager
*m
) {
729 m
->event_receive
= sd_event_source_unref(m
->event_receive
);
730 m
->server_socket
= safe_close(m
->server_socket
);
733 static int manager_begin(Manager
*m
) {
734 _cleanup_free_
char *pretty
= NULL
;
738 assert_return(m
->current_server_name
, -EHOSTUNREACH
);
739 assert_return(m
->current_server_address
, -EHOSTUNREACH
);
742 m
->missed_replies
= NTP_MAX_MISSED_REPLIES
;
743 if (m
->poll_interval_usec
== 0)
744 m
->poll_interval_usec
= NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
;
746 server_address_pretty(m
->current_server_address
, &pretty
);
747 log_debug("Connecting to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
748 sd_notifyf(false, "STATUS=Connecting to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
750 r
= manager_clock_watch_setup(m
);
754 return manager_send_request(m
);
757 void manager_set_server_name(Manager
*m
, ServerName
*n
) {
760 if (m
->current_server_name
== n
)
763 m
->current_server_name
= n
;
764 m
->current_server_address
= NULL
;
766 manager_disconnect(m
);
769 log_debug("Selected server %s.", n
->string
);
772 void manager_set_server_address(Manager
*m
, ServerAddress
*a
) {
775 if (m
->current_server_address
== a
)
778 m
->current_server_address
= a
;
779 /* If a is NULL, we are just clearing the address, without
780 * changing the name. Keep the existing name in that case. */
782 m
->current_server_name
= a
->name
;
784 manager_disconnect(m
);
787 _cleanup_free_
char *pretty
= NULL
;
788 server_address_pretty(a
, &pretty
);
789 log_debug("Selected address %s of server %s.", strna(pretty
), a
->name
->string
);
793 static int manager_resolve_handler(sd_resolve_query
*q
, int ret
, const struct addrinfo
*ai
, void *userdata
) {
794 Manager
*m
= userdata
;
799 assert(m
->current_server_name
);
801 m
->resolve_query
= sd_resolve_query_unref(m
->resolve_query
);
804 log_debug("Failed to resolve %s: %s", m
->current_server_name
->string
, gai_strerror(ret
));
807 return manager_connect(m
);
810 for (; ai
; ai
= ai
->ai_next
) {
811 _cleanup_free_
char *pretty
= NULL
;
815 assert(ai
->ai_addrlen
>= offsetof(struct sockaddr
, sa_data
));
817 if (!IN_SET(ai
->ai_addr
->sa_family
, AF_INET
, AF_INET6
)) {
818 log_warning("Unsuitable address protocol for %s", m
->current_server_name
->string
);
822 r
= server_address_new(m
->current_server_name
, &a
, (const union sockaddr_union
*) ai
->ai_addr
, ai
->ai_addrlen
);
824 return log_error_errno(r
, "Failed to add server address: %m");
826 server_address_pretty(a
, &pretty
);
827 log_debug("Resolved address %s for %s.", pretty
, m
->current_server_name
->string
);
830 if (!m
->current_server_name
->addresses
) {
831 log_error("Failed to find suitable address for host %s.", m
->current_server_name
->string
);
834 return manager_connect(m
);
837 manager_set_server_address(m
, m
->current_server_name
->addresses
);
839 return manager_begin(m
);
842 static int manager_retry_connect(sd_event_source
*source
, usec_t usec
, void *userdata
) {
843 Manager
*m
= userdata
;
847 return manager_connect(m
);
850 int manager_connect(Manager
*m
) {
855 manager_disconnect(m
);
857 m
->event_retry
= sd_event_source_unref(m
->event_retry
);
858 if (!ratelimit_test(&m
->ratelimit
)) {
859 log_debug("Slowing down attempts to contact servers.");
861 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
);
863 return log_error_errno(r
, "Failed to create retry timer: %m");
868 /* If we already are operating on some address, switch to the
870 if (m
->current_server_address
&& m
->current_server_address
->addresses_next
)
871 manager_set_server_address(m
, m
->current_server_address
->addresses_next
);
873 struct addrinfo hints
= {
874 .ai_flags
= AI_NUMERICSERV
|AI_ADDRCONFIG
,
875 .ai_socktype
= SOCK_DGRAM
,
878 /* Hmm, we are through all addresses, let's look for the next host instead */
879 if (m
->current_server_name
&& m
->current_server_name
->names_next
)
880 manager_set_server_name(m
, m
->current_server_name
->names_next
);
885 /* Our current server name list is exhausted,
886 * let's find the next one to iterate. First
887 * we try the system list, then the link list.
888 * After having processed the link list we
889 * jump back to the system list. However, if
890 * both lists are empty, we change to the
892 if (!m
->current_server_name
|| m
->current_server_name
->type
== SERVER_LINK
) {
893 f
= m
->system_servers
;
899 f
= m
->system_servers
;
905 f
= m
->fallback_servers
;
908 manager_set_server_name(m
, NULL
);
909 log_debug("No server found.");
913 if (restart
&& !m
->exhausted_servers
&& m
->poll_interval_usec
) {
914 log_debug("Waiting after exhausting servers.");
915 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
);
917 return log_error_errno(r
, "Failed to create retry timer: %m");
919 m
->exhausted_servers
= true;
921 /* Increase the polling interval */
922 if (m
->poll_interval_usec
< NTP_POLL_INTERVAL_MAX_SEC
* USEC_PER_SEC
)
923 m
->poll_interval_usec
*= 2;
928 m
->exhausted_servers
= false;
930 manager_set_server_name(m
, f
);
933 /* Tell the resolver to reread /etc/resolv.conf, in
934 * case it changed. */
937 /* Flush out any previously resolved addresses */
938 server_name_flush_addresses(m
->current_server_name
);
940 log_debug("Resolving %s...", m
->current_server_name
->string
);
942 r
= sd_resolve_getaddrinfo(m
->resolve
, &m
->resolve_query
, m
->current_server_name
->string
, "123", &hints
, manager_resolve_handler
, m
);
944 return log_error_errno(r
, "Failed to create resolver: %m");
949 r
= manager_begin(m
);
956 void manager_disconnect(Manager
*m
) {
959 m
->resolve_query
= sd_resolve_query_unref(m
->resolve_query
);
961 m
->event_timer
= sd_event_source_unref(m
->event_timer
);
963 manager_listen_stop(m
);
965 m
->event_clock_watch
= sd_event_source_unref(m
->event_clock_watch
);
966 m
->clock_watch_fd
= safe_close(m
->clock_watch_fd
);
968 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
970 sd_notifyf(false, "STATUS=Idle.");
973 void manager_flush_server_names(Manager
*m
, ServerType t
) {
976 if (t
== SERVER_SYSTEM
)
977 while (m
->system_servers
)
978 server_name_free(m
->system_servers
);
980 if (t
== SERVER_LINK
)
981 while (m
->link_servers
)
982 server_name_free(m
->link_servers
);
984 if (t
== SERVER_FALLBACK
)
985 while (m
->fallback_servers
)
986 server_name_free(m
->fallback_servers
);
989 void manager_free(Manager
*m
) {
993 manager_disconnect(m
);
994 manager_flush_server_names(m
, SERVER_SYSTEM
);
995 manager_flush_server_names(m
, SERVER_LINK
);
996 manager_flush_server_names(m
, SERVER_FALLBACK
);
998 sd_event_source_unref(m
->event_retry
);
1000 sd_event_source_unref(m
->network_event_source
);
1001 sd_network_monitor_unref(m
->network_monitor
);
1003 sd_resolve_unref(m
->resolve
);
1004 sd_event_unref(m
->event
);
1009 static int manager_network_read_link_servers(Manager
*m
) {
1010 _cleanup_strv_free_
char **ntp
= NULL
;
1017 r
= sd_network_get_ntp(&ntp
);
1021 LIST_FOREACH(names
, n
, m
->link_servers
)
1024 STRV_FOREACH(i
, ntp
) {
1027 LIST_FOREACH(names
, n
, m
->link_servers
)
1028 if (streq(n
->string
, *i
)) {
1035 r
= server_name_new(m
, NULL
, SERVER_LINK
, *i
);
1041 LIST_FOREACH_SAFE(names
, n
, nx
, m
->link_servers
)
1043 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 connected
, online
;
1059 sd_network_monitor_flush(m
->network_monitor
);
1061 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
) {
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
);
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
->server_socket
= m
->clock_watch_fd
= -1;
1123 RATELIMIT_INIT(m
->ratelimit
, RATELIMIT_INTERVAL_USEC
, RATELIMIT_BURST
);
1125 r
= manager_parse_server_string(m
, SERVER_FALLBACK
, NTP_SERVERS
);
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
);