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"
39 #include "network-util.h"
40 #include "ratelimit.h"
41 #include "socket-util.h"
42 #include "sparse-endian.h"
43 #include "string-util.h"
45 #include "time-util.h"
46 #include "timesyncd-conf.h"
48 #include "timesyncd-manager.h"
51 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
54 /* expected accuracy of time synchronization; used to adjust the poll interval */
55 #define NTP_ACCURACY_SEC 0.2
58 * "A client MUST NOT under any conditions use a poll interval less
61 #define NTP_POLL_INTERVAL_MIN_SEC 32
62 #define NTP_POLL_INTERVAL_MAX_SEC 2048
65 * Maximum delta in seconds which the system clock is gradually adjusted
66 * (slew) to approach the network time. Deltas larger that this are set by
67 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
69 #define NTP_MAX_ADJUST 0.4
71 /* NTP protocol, packet header */
72 #define NTP_LEAP_PLUSSEC 1
73 #define NTP_LEAP_MINUSSEC 2
74 #define NTP_LEAP_NOTINSYNC 3
75 #define NTP_MODE_CLIENT 3
76 #define NTP_MODE_SERVER 4
77 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
78 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
79 #define NTP_FIELD_MODE(f) ((f) & 7)
80 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
82 /* Maximum acceptable root distance in seconds. */
83 #define NTP_MAX_ROOT_DISTANCE 5.0
85 /* Maximum number of missed replies before selecting another source. */
86 #define NTP_MAX_MISSED_REPLIES 2
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 UINT64_C(2208988800)
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 int manager_arm_timer(Manager
*m
, usec_t next
);
125 static int manager_clock_watch_setup(Manager
*m
);
126 static int manager_listen_setup(Manager
*m
);
127 static void manager_listen_stop(Manager
*m
);
129 static double ntp_ts_short_to_d(const struct ntp_ts_short
*ts
) {
130 return be16toh(ts
->sec
) + (be16toh(ts
->frac
) / 65536.0);
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 int manager_timeout(sd_event_source
*source
, usec_t usec
, void *userdata
) {
142 _cleanup_free_
char *pretty
= NULL
;
143 Manager
*m
= userdata
;
146 assert(m
->current_server_name
);
147 assert(m
->current_server_address
);
149 server_address_pretty(m
->current_server_address
, &pretty
);
150 log_info("Timed out waiting for reply from %s (%s).", strna(pretty
), m
->current_server_name
->string
);
152 return manager_connect(m
);
155 static int manager_send_request(Manager
*m
) {
156 _cleanup_free_
char *pretty
= NULL
;
157 struct ntp_msg ntpmsg
= {
159 * "The client initializes the NTP message header, sends the request
160 * to the server, and strips the time of day from the Transmit
161 * Timestamp field of the reply. For this purpose, all the NTP
162 * header fields are set to 0, except the Mode, VN, and optional
163 * Transmit Timestamp fields."
165 .field
= NTP_FIELD(0, 4, NTP_MODE_CLIENT
),
171 assert(m
->current_server_name
);
172 assert(m
->current_server_address
);
174 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
176 r
= manager_listen_setup(m
);
178 return log_warning_errno(r
, "Failed to setup connection socket: %m");
181 * Set transmit timestamp, remember it; the server will send that back
182 * as the origin timestamp and we have an indication that this is the
183 * matching answer to our request.
185 * The actual value does not matter, We do not care about the correct
186 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
188 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m
->trans_time_mon
) >= 0);
189 assert_se(clock_gettime(CLOCK_REALTIME
, &m
->trans_time
) >= 0);
190 ntpmsg
.trans_time
.sec
= htobe32(m
->trans_time
.tv_sec
+ OFFSET_1900_1970
);
191 ntpmsg
.trans_time
.frac
= htobe32(m
->trans_time
.tv_nsec
);
193 server_address_pretty(m
->current_server_address
, &pretty
);
195 len
= sendto(m
->server_socket
, &ntpmsg
, sizeof(ntpmsg
), MSG_DONTWAIT
, &m
->current_server_address
->sockaddr
.sa
, m
->current_server_address
->socklen
);
196 if (len
== sizeof(ntpmsg
)) {
198 log_debug("Sent NTP request to %s (%s).", strna(pretty
), m
->current_server_name
->string
);
200 log_debug_errno(errno
, "Sending NTP request to %s (%s) failed: %m", strna(pretty
), m
->current_server_name
->string
);
201 return manager_connect(m
);
204 /* re-arm timer with increasing timeout, in case the packets never arrive back */
205 if (m
->retry_interval
> 0) {
206 if (m
->retry_interval
< NTP_POLL_INTERVAL_MAX_SEC
* USEC_PER_SEC
)
207 m
->retry_interval
*= 2;
209 m
->retry_interval
= NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
;
211 r
= manager_arm_timer(m
, m
->retry_interval
);
213 return log_error_errno(r
, "Failed to rearm timer: %m");
216 if (m
->missed_replies
> NTP_MAX_MISSED_REPLIES
) {
217 r
= sd_event_add_time(
220 clock_boottime_or_monotonic(),
221 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC
, 0,
224 return log_error_errno(r
, "Failed to arm timeout timer: %m");
230 static int manager_timer(sd_event_source
*source
, usec_t usec
, void *userdata
) {
231 Manager
*m
= userdata
;
235 return manager_send_request(m
);
238 static int manager_arm_timer(Manager
*m
, usec_t next
) {
244 m
->event_timer
= sd_event_source_unref(m
->event_timer
);
248 if (m
->event_timer
) {
249 r
= sd_event_source_set_time(m
->event_timer
, now(clock_boottime_or_monotonic()) + next
);
253 return sd_event_source_set_enabled(m
->event_timer
, SD_EVENT_ONESHOT
);
256 return sd_event_add_time(
259 clock_boottime_or_monotonic(),
260 now(clock_boottime_or_monotonic()) + next
, 0,
264 static int manager_clock_watch(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
265 Manager
*m
= userdata
;
270 manager_clock_watch_setup(m
);
272 /* skip our own jumps */
279 log_debug("System time changed. Resyncing.");
280 m
->poll_resync
= true;
282 return manager_send_request(m
);
285 /* wake up when the system time changes underneath us */
286 static int manager_clock_watch_setup(Manager
*m
) {
288 struct itimerspec its
= {
289 .it_value
.tv_sec
= TIME_T_MAX
296 m
->event_clock_watch
= sd_event_source_unref(m
->event_clock_watch
);
297 safe_close(m
->clock_watch_fd
);
299 m
->clock_watch_fd
= timerfd_create(CLOCK_REALTIME
, TFD_NONBLOCK
|TFD_CLOEXEC
);
300 if (m
->clock_watch_fd
< 0)
301 return log_error_errno(errno
, "Failed to create timerfd: %m");
303 if (timerfd_settime(m
->clock_watch_fd
, TFD_TIMER_ABSTIME
|TFD_TIMER_CANCEL_ON_SET
, &its
, NULL
) < 0)
304 return log_error_errno(errno
, "Failed to set up timerfd: %m");
306 r
= sd_event_add_io(m
->event
, &m
->event_clock_watch
, m
->clock_watch_fd
, EPOLLIN
, manager_clock_watch
, m
);
308 return log_error_errno(r
, "Failed to create clock watch event source: %m");
313 static int manager_adjust_clock(Manager
*m
, double offset
, int leap_sec
) {
314 struct timex tmx
= {};
320 * For small deltas, tell the kernel to gradually adjust the system
321 * clock to the NTP time, larger deltas are just directly set.
323 if (fabs(offset
) < NTP_MAX_ADJUST
) {
324 tmx
.modes
= ADJ_STATUS
| ADJ_NANO
| ADJ_OFFSET
| ADJ_TIMECONST
| ADJ_MAXERROR
| ADJ_ESTERROR
;
325 tmx
.status
= STA_PLL
;
326 tmx
.offset
= offset
* NSEC_PER_SEC
;
327 tmx
.constant
= log2i(m
->poll_interval_usec
/ USEC_PER_SEC
) - 4;
330 log_debug(" adjust (slew): %+.3f sec", offset
);
332 tmx
.modes
= ADJ_STATUS
| ADJ_NANO
| ADJ_SETOFFSET
;
334 /* ADJ_NANO uses nanoseconds in the microseconds field */
335 tmx
.time
.tv_sec
= (long)offset
;
336 tmx
.time
.tv_usec
= (offset
- tmx
.time
.tv_sec
) * NSEC_PER_SEC
;
338 /* the kernel expects -0.3s as {-1, 7000.000.000} */
339 if (tmx
.time
.tv_usec
< 0) {
340 tmx
.time
.tv_sec
-= 1;
341 tmx
.time
.tv_usec
+= NSEC_PER_SEC
;
345 log_debug(" adjust (jump): %+.3f sec", offset
);
349 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
350 * which syncs the system time periodically to the RTC.
352 * In case the RTC runs in local time, never touch the RTC,
353 * we have no way to properly handle daylight saving changes and
354 * mobile devices moving between time zones.
356 if (m
->rtc_local_time
)
357 tmx
.status
|= STA_UNSYNC
;
361 tmx
.status
|= STA_INS
;
364 tmx
.status
|= STA_DEL
;
368 r
= clock_adjtime(CLOCK_REALTIME
, &tmx
);
372 touch("/var/lib/systemd/clock");
374 m
->drift_ppm
= tmx
.freq
/ 65536;
376 log_debug(" status : %04i %s\n"
377 " time now : %li.%03llu\n"
379 " offset : %+.3f sec\n"
380 " freq offset : %+li (%i ppm)\n",
381 tmx
.status
, tmx
.status
& STA_UNSYNC
? "unsync" : "sync",
382 tmx
.time
.tv_sec
, (unsigned long long) (tmx
.time
.tv_usec
/ NSEC_PER_MSEC
),
384 (double)tmx
.offset
/ NSEC_PER_SEC
,
385 tmx
.freq
, m
->drift_ppm
);
390 static bool manager_sample_spike_detection(Manager
*m
, double offset
, double delay
) {
391 unsigned int i
, idx_cur
, idx_new
, idx_min
;
399 /* ignore initial sample */
400 if (m
->packet_count
== 1)
403 /* store the current data in our samples array */
404 idx_cur
= m
->samples_idx
;
405 idx_new
= (idx_cur
+ 1) % ELEMENTSOF(m
->samples
);
406 m
->samples_idx
= idx_new
;
407 m
->samples
[idx_new
].offset
= offset
;
408 m
->samples
[idx_new
].delay
= delay
;
410 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
411 jitter
= m
->samples_jitter
;
412 for (idx_min
= idx_cur
, i
= 0; i
< ELEMENTSOF(m
->samples
); i
++)
413 if (m
->samples
[i
].delay
> 0 && m
->samples
[i
].delay
< m
->samples
[idx_min
].delay
)
417 for (i
= 0; i
< ELEMENTSOF(m
->samples
); i
++)
418 j
+= pow(m
->samples
[i
].offset
- m
->samples
[idx_min
].offset
, 2);
419 m
->samples_jitter
= sqrt(j
/ (ELEMENTSOF(m
->samples
) - 1));
421 /* ignore samples when resyncing */
425 /* always accept offset if we are farther off than the round-trip delay */
426 if (fabs(offset
) > delay
)
429 /* we need a few samples before looking at them */
430 if (m
->packet_count
< 4)
433 /* do not accept anything worse than the maximum possible error of the best sample */
434 if (fabs(offset
) > m
->samples
[idx_min
].delay
)
437 /* compare the difference between the current offset to the previous offset and jitter */
438 return fabs(offset
- m
->samples
[idx_cur
].offset
) > 3 * jitter
;
441 static void manager_adjust_poll(Manager
*m
, double offset
, bool spike
) {
444 if (m
->poll_resync
) {
445 m
->poll_interval_usec
= NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
;
446 m
->poll_resync
= false;
450 /* set to minimal poll interval */
451 if (!spike
&& fabs(offset
) > NTP_ACCURACY_SEC
) {
452 m
->poll_interval_usec
= NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
;
456 /* increase polling interval */
457 if (fabs(offset
) < NTP_ACCURACY_SEC
* 0.25) {
458 if (m
->poll_interval_usec
< NTP_POLL_INTERVAL_MAX_SEC
* USEC_PER_SEC
)
459 m
->poll_interval_usec
*= 2;
463 /* decrease polling interval */
464 if (spike
|| fabs(offset
) > NTP_ACCURACY_SEC
* 0.75) {
465 if (m
->poll_interval_usec
> NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
)
466 m
->poll_interval_usec
/= 2;
471 static int manager_receive_response(sd_event_source
*source
, int fd
, uint32_t revents
, void *userdata
) {
472 Manager
*m
= userdata
;
473 struct ntp_msg ntpmsg
;
477 .iov_len
= sizeof(ntpmsg
),
480 struct cmsghdr cmsghdr
;
481 uint8_t buf
[CMSG_SPACE(sizeof(struct timeval
))];
483 union sockaddr_union server_addr
;
484 struct msghdr msghdr
= {
487 .msg_control
= &control
,
488 .msg_controllen
= sizeof(control
),
489 .msg_name
= &server_addr
,
490 .msg_namelen
= sizeof(server_addr
),
492 struct cmsghdr
*cmsg
;
493 struct timespec
*recv_time
;
495 double origin
, receive
, trans
, dest
;
496 double delay
, offset
;
497 double root_distance
;
505 if (revents
& (EPOLLHUP
|EPOLLERR
)) {
506 log_warning("Server connection returned error.");
507 return manager_connect(m
);
510 len
= recvmsg(fd
, &msghdr
, MSG_DONTWAIT
);
515 log_warning("Error receiving message. Disconnecting.");
516 return manager_connect(m
);
519 /* Too short or too long packet? */
520 if (iov
.iov_len
< sizeof(struct ntp_msg
) || (msghdr
.msg_flags
& MSG_TRUNC
)) {
521 log_warning("Invalid response from server. Disconnecting.");
522 return manager_connect(m
);
525 if (!m
->current_server_name
||
526 !m
->current_server_address
||
527 !sockaddr_equal(&server_addr
, &m
->current_server_address
->sockaddr
)) {
528 log_debug("Response from unknown server.");
533 CMSG_FOREACH(cmsg
, &msghdr
) {
534 if (cmsg
->cmsg_level
!= SOL_SOCKET
)
537 switch (cmsg
->cmsg_type
) {
538 case SCM_TIMESTAMPNS
:
539 recv_time
= (struct timespec
*) CMSG_DATA(cmsg
);
544 log_error("Invalid packet timestamp.");
549 log_debug("Unexpected reply. Ignoring.");
553 m
->missed_replies
= 0;
555 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
556 if (be32toh(ntpmsg
.origin_time
.sec
) != m
->trans_time
.tv_sec
+ OFFSET_1900_1970
||
557 be32toh(ntpmsg
.origin_time
.frac
) != m
->trans_time
.tv_nsec
) {
558 log_debug("Invalid reply; not our transmit time. Ignoring.");
562 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
564 if (be32toh(ntpmsg
.recv_time
.sec
) < TIME_EPOCH
+ OFFSET_1900_1970
||
565 be32toh(ntpmsg
.trans_time
.sec
) < TIME_EPOCH
+ OFFSET_1900_1970
) {
566 log_debug("Invalid reply, returned times before epoch. Ignoring.");
567 return manager_connect(m
);
570 if (NTP_FIELD_LEAP(ntpmsg
.field
) == NTP_LEAP_NOTINSYNC
||
571 ntpmsg
.stratum
== 0 || ntpmsg
.stratum
>= 16) {
572 log_debug("Server is not synchronized. Disconnecting.");
573 return manager_connect(m
);
576 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg
.field
), 3, 4)) {
577 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg
.field
));
578 return manager_connect(m
);
581 if (NTP_FIELD_MODE(ntpmsg
.field
) != NTP_MODE_SERVER
) {
582 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg
.field
));
583 return manager_connect(m
);
586 root_distance
= ntp_ts_short_to_d(&ntpmsg
.root_delay
) / 2 + ntp_ts_short_to_d(&ntpmsg
.root_dispersion
);
587 if (root_distance
> NTP_MAX_ROOT_DISTANCE
) {
588 log_debug("Server has too large root distance. Disconnecting.");
589 return manager_connect(m
);
594 m
->retry_interval
= 0;
597 manager_listen_stop(m
);
599 /* announce leap seconds */
600 if (NTP_FIELD_LEAP(ntpmsg
.field
) & NTP_LEAP_PLUSSEC
)
602 else if (NTP_FIELD_LEAP(ntpmsg
.field
) & NTP_LEAP_MINUSSEC
)
608 * "Timestamp Name ID When Generated
609 * ------------------------------------------------------------
610 * Originate Timestamp T1 time request sent by client
611 * Receive Timestamp T2 time request received by server
612 * Transmit Timestamp T3 time reply sent by server
613 * Destination Timestamp T4 time reply received by client
615 * The round-trip delay, d, and system clock offset, t, are defined as:
616 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
618 origin
= ts_to_d(&m
->trans_time
) + OFFSET_1900_1970
;
619 receive
= ntp_ts_to_d(&ntpmsg
.recv_time
);
620 trans
= ntp_ts_to_d(&ntpmsg
.trans_time
);
621 dest
= ts_to_d(recv_time
) + OFFSET_1900_1970
;
623 offset
= ((receive
- origin
) + (trans
- dest
)) / 2;
624 delay
= (dest
- origin
) - (trans
- receive
);
626 spike
= manager_sample_spike_detection(m
, offset
, delay
);
628 manager_adjust_poll(m
, offset
, spike
);
630 log_debug("NTP response:\n"
635 " precision : %.6f sec (%d)\n"
636 " root distance: %.6f sec\n"
637 " reference : %.4s\n"
642 " offset : %+.3f sec\n"
643 " delay : %+.3f sec\n"
644 " packet count : %"PRIu64
"\n"
646 " poll interval: " USEC_FMT
"\n",
647 NTP_FIELD_LEAP(ntpmsg
.field
),
648 NTP_FIELD_VERSION(ntpmsg
.field
),
649 NTP_FIELD_MODE(ntpmsg
.field
),
651 exp2(ntpmsg
.precision
), ntpmsg
.precision
,
653 ntpmsg
.stratum
== 1 ? ntpmsg
.refid
: "n/a",
654 origin
- OFFSET_1900_1970
,
655 receive
- OFFSET_1900_1970
,
656 trans
- OFFSET_1900_1970
,
657 dest
- OFFSET_1900_1970
,
660 m
->samples_jitter
, spike
? " spike" : "",
661 m
->poll_interval_usec
/ USEC_PER_SEC
);
665 r
= manager_adjust_clock(m
, offset
, leap_sec
);
667 log_error_errno(errno
, "Failed to call clock_adjtime(): %m");
670 log_debug("interval/delta/delay/jitter/drift " USEC_FMT
"s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
671 m
->poll_interval_usec
/ USEC_PER_SEC
, offset
, delay
, m
->samples_jitter
, m
->drift_ppm
,
672 spike
? " (ignored)" : "");
675 _cleanup_free_
char *pretty
= NULL
;
679 server_address_pretty(m
->current_server_address
, &pretty
);
680 log_info("Synchronized to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
681 sd_notifyf(false, "STATUS=Synchronized to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
684 r
= manager_arm_timer(m
, m
->poll_interval_usec
);
686 return log_error_errno(r
, "Failed to rearm timer: %m");
691 static int manager_listen_setup(Manager
*m
) {
692 union sockaddr_union addr
= {};
693 static const int tos
= IPTOS_LOWDELAY
;
694 static const int on
= 1;
699 if (m
->server_socket
>= 0)
702 assert(!m
->event_receive
);
703 assert(m
->current_server_address
);
705 addr
.sa
.sa_family
= m
->current_server_address
->sockaddr
.sa
.sa_family
;
707 m
->server_socket
= socket(addr
.sa
.sa_family
, SOCK_DGRAM
| SOCK_CLOEXEC
, 0);
708 if (m
->server_socket
< 0)
711 r
= bind(m
->server_socket
, &addr
.sa
, m
->current_server_address
->socklen
);
715 r
= setsockopt(m
->server_socket
, SOL_SOCKET
, SO_TIMESTAMPNS
, &on
, sizeof(on
));
719 (void) setsockopt(m
->server_socket
, IPPROTO_IP
, IP_TOS
, &tos
, sizeof(tos
));
721 return sd_event_add_io(m
->event
, &m
->event_receive
, m
->server_socket
, EPOLLIN
, manager_receive_response
, m
);
724 static void manager_listen_stop(Manager
*m
) {
727 m
->event_receive
= sd_event_source_unref(m
->event_receive
);
728 m
->server_socket
= safe_close(m
->server_socket
);
731 static int manager_begin(Manager
*m
) {
732 _cleanup_free_
char *pretty
= NULL
;
736 assert_return(m
->current_server_name
, -EHOSTUNREACH
);
737 assert_return(m
->current_server_address
, -EHOSTUNREACH
);
740 m
->missed_replies
= NTP_MAX_MISSED_REPLIES
;
741 if (m
->poll_interval_usec
== 0)
742 m
->poll_interval_usec
= NTP_POLL_INTERVAL_MIN_SEC
* USEC_PER_SEC
;
744 server_address_pretty(m
->current_server_address
, &pretty
);
745 log_debug("Connecting to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
746 sd_notifyf(false, "STATUS=Connecting to time server %s (%s).", strna(pretty
), m
->current_server_name
->string
);
748 r
= manager_clock_watch_setup(m
);
752 return manager_send_request(m
);
755 void manager_set_server_name(Manager
*m
, ServerName
*n
) {
758 if (m
->current_server_name
== n
)
761 m
->current_server_name
= n
;
762 m
->current_server_address
= NULL
;
764 manager_disconnect(m
);
767 log_debug("Selected server %s.", n
->string
);
770 void manager_set_server_address(Manager
*m
, ServerAddress
*a
) {
773 if (m
->current_server_address
== a
)
776 m
->current_server_address
= a
;
777 /* If a is NULL, we are just clearing the address, without
778 * changing the name. Keep the existing name in that case. */
780 m
->current_server_name
= a
->name
;
782 manager_disconnect(m
);
785 _cleanup_free_
char *pretty
= NULL
;
786 server_address_pretty(a
, &pretty
);
787 log_debug("Selected address %s of server %s.", strna(pretty
), a
->name
->string
);
791 static int manager_resolve_handler(sd_resolve_query
*q
, int ret
, const struct addrinfo
*ai
, void *userdata
) {
792 Manager
*m
= userdata
;
797 assert(m
->current_server_name
);
799 m
->resolve_query
= sd_resolve_query_unref(m
->resolve_query
);
802 log_debug("Failed to resolve %s: %s", m
->current_server_name
->string
, gai_strerror(ret
));
805 return manager_connect(m
);
808 for (; ai
; ai
= ai
->ai_next
) {
809 _cleanup_free_
char *pretty
= NULL
;
813 assert(ai
->ai_addrlen
>= offsetof(struct sockaddr
, sa_data
));
815 if (!IN_SET(ai
->ai_addr
->sa_family
, AF_INET
, AF_INET6
)) {
816 log_warning("Unsuitable address protocol for %s", m
->current_server_name
->string
);
820 r
= server_address_new(m
->current_server_name
, &a
, (const union sockaddr_union
*) ai
->ai_addr
, ai
->ai_addrlen
);
822 return log_error_errno(r
, "Failed to add server address: %m");
824 server_address_pretty(a
, &pretty
);
825 log_debug("Resolved address %s for %s.", pretty
, m
->current_server_name
->string
);
828 if (!m
->current_server_name
->addresses
) {
829 log_error("Failed to find suitable address for host %s.", m
->current_server_name
->string
);
832 return manager_connect(m
);
835 manager_set_server_address(m
, m
->current_server_name
->addresses
);
837 return manager_begin(m
);
840 static int manager_retry_connect(sd_event_source
*source
, usec_t usec
, void *userdata
) {
841 Manager
*m
= userdata
;
845 return manager_connect(m
);
848 int manager_connect(Manager
*m
) {
853 manager_disconnect(m
);
855 m
->event_retry
= sd_event_source_unref(m
->event_retry
);
856 if (!ratelimit_test(&m
->ratelimit
)) {
857 log_debug("Slowing down attempts to contact servers.");
859 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
);
861 return log_error_errno(r
, "Failed to create retry timer: %m");
866 /* If we already are operating on some address, switch to the
868 if (m
->current_server_address
&& m
->current_server_address
->addresses_next
)
869 manager_set_server_address(m
, m
->current_server_address
->addresses_next
);
871 struct addrinfo hints
= {
872 .ai_flags
= AI_NUMERICSERV
|AI_ADDRCONFIG
,
873 .ai_socktype
= SOCK_DGRAM
,
876 /* Hmm, we are through all addresses, let's look for the next host instead */
877 if (m
->current_server_name
&& m
->current_server_name
->names_next
)
878 manager_set_server_name(m
, m
->current_server_name
->names_next
);
883 /* Our current server name list is exhausted,
884 * let's find the next one to iterate. First
885 * we try the system list, then the link list.
886 * After having processed the link list we
887 * jump back to the system list. However, if
888 * both lists are empty, we change to the
890 if (!m
->current_server_name
|| m
->current_server_name
->type
== SERVER_LINK
) {
891 f
= m
->system_servers
;
897 f
= m
->system_servers
;
903 f
= m
->fallback_servers
;
906 manager_set_server_name(m
, NULL
);
907 log_debug("No server found.");
911 if (restart
&& !m
->exhausted_servers
&& m
->poll_interval_usec
) {
912 log_debug("Waiting after exhausting servers.");
913 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
);
915 return log_error_errno(r
, "Failed to create retry timer: %m");
917 m
->exhausted_servers
= true;
919 /* Increase the polling interval */
920 if (m
->poll_interval_usec
< NTP_POLL_INTERVAL_MAX_SEC
* USEC_PER_SEC
)
921 m
->poll_interval_usec
*= 2;
926 m
->exhausted_servers
= false;
928 manager_set_server_name(m
, f
);
931 /* Tell the resolver to reread /etc/resolv.conf, in
932 * case it changed. */
935 /* Flush out any previously resolved addresses */
936 server_name_flush_addresses(m
->current_server_name
);
938 log_debug("Resolving %s...", m
->current_server_name
->string
);
940 r
= sd_resolve_getaddrinfo(m
->resolve
, &m
->resolve_query
, m
->current_server_name
->string
, "123", &hints
, manager_resolve_handler
, m
);
942 return log_error_errno(r
, "Failed to create resolver: %m");
947 r
= manager_begin(m
);
954 void manager_disconnect(Manager
*m
) {
957 m
->resolve_query
= sd_resolve_query_unref(m
->resolve_query
);
959 m
->event_timer
= sd_event_source_unref(m
->event_timer
);
961 manager_listen_stop(m
);
963 m
->event_clock_watch
= sd_event_source_unref(m
->event_clock_watch
);
964 m
->clock_watch_fd
= safe_close(m
->clock_watch_fd
);
966 m
->event_timeout
= sd_event_source_unref(m
->event_timeout
);
968 sd_notifyf(false, "STATUS=Idle.");
971 void manager_flush_server_names(Manager
*m
, ServerType t
) {
974 if (t
== SERVER_SYSTEM
)
975 while (m
->system_servers
)
976 server_name_free(m
->system_servers
);
978 if (t
== SERVER_LINK
)
979 while (m
->link_servers
)
980 server_name_free(m
->link_servers
);
982 if (t
== SERVER_FALLBACK
)
983 while (m
->fallback_servers
)
984 server_name_free(m
->fallback_servers
);
987 void manager_free(Manager
*m
) {
991 manager_disconnect(m
);
992 manager_flush_server_names(m
, SERVER_SYSTEM
);
993 manager_flush_server_names(m
, SERVER_LINK
);
994 manager_flush_server_names(m
, SERVER_FALLBACK
);
996 sd_event_source_unref(m
->event_retry
);
998 sd_event_source_unref(m
->network_event_source
);
999 sd_network_monitor_unref(m
->network_monitor
);
1001 sd_resolve_unref(m
->resolve
);
1002 sd_event_unref(m
->event
);
1007 static int manager_network_read_link_servers(Manager
*m
) {
1008 _cleanup_strv_free_
char **ntp
= NULL
;
1015 r
= sd_network_get_ntp(&ntp
);
1019 LIST_FOREACH(names
, n
, m
->link_servers
)
1022 STRV_FOREACH(i
, ntp
) {
1025 LIST_FOREACH(names
, n
, m
->link_servers
)
1026 if (streq(n
->string
, *i
)) {
1033 r
= server_name_new(m
, NULL
, SERVER_LINK
, *i
);
1039 LIST_FOREACH_SAFE(names
, n
, nx
, m
->link_servers
)
1041 server_name_free(n
);
1046 manager_flush_server_names(m
, SERVER_LINK
);
1050 static int manager_network_event_handler(sd_event_source
*s
, int fd
, uint32_t revents
, void *userdata
) {
1051 Manager
*m
= userdata
;
1052 bool connected
, online
;
1057 sd_network_monitor_flush(m
->network_monitor
);
1059 manager_network_read_link_servers(m
);
1061 /* check if the machine is online */
1062 online
= network_is_online();
1064 /* check if the client is currently connected */
1065 connected
= m
->server_socket
>= 0 || m
->resolve_query
|| m
->exhausted_servers
;
1067 if (connected
&& !online
) {
1068 log_info("No network connectivity, watching for changes.");
1069 manager_disconnect(m
);
1071 } else if (!connected
&& online
) {
1072 log_info("Network configuration changed, trying to establish connection.");
1074 if (m
->current_server_address
)
1075 r
= manager_begin(m
);
1077 r
= manager_connect(m
);
1085 static int manager_network_monitor_listen(Manager
*m
) {
1090 r
= sd_network_monitor_new(&m
->network_monitor
, NULL
);
1094 fd
= sd_network_monitor_get_fd(m
->network_monitor
);
1098 events
= sd_network_monitor_get_events(m
->network_monitor
);
1102 r
= sd_event_add_io(m
->event
, &m
->network_event_source
, fd
, events
, manager_network_event_handler
, m
);
1109 int manager_new(Manager
**ret
) {
1110 _cleanup_(manager_freep
) Manager
*m
= NULL
;
1115 m
= new0(Manager
, 1);
1119 m
->server_socket
= m
->clock_watch_fd
= -1;
1121 RATELIMIT_INIT(m
->ratelimit
, RATELIMIT_INTERVAL_USEC
, RATELIMIT_BURST
);
1123 r
= manager_parse_server_string(m
, SERVER_FALLBACK
, NTP_SERVERS
);
1127 r
= sd_event_default(&m
->event
);
1131 sd_event_add_signal(m
->event
, NULL
, SIGTERM
, NULL
, NULL
);
1132 sd_event_add_signal(m
->event
, NULL
, SIGINT
, NULL
, NULL
);
1134 sd_event_set_watchdog(m
->event
, true);
1136 r
= sd_resolve_default(&m
->resolve
);
1140 r
= sd_resolve_attach_event(m
->resolve
, m
->event
, 0);
1144 r
= manager_network_monitor_listen(m
);
1148 manager_network_read_link_servers(m
);