]> git.ipfire.org Git - thirdparty/systemd.git/blob - src/timesync/timesyncd-manager.c
projects / thirdparty / systemd.git / blob
? search:


8e4c0f3392192186a54879ba12916ff8f09586ff
[thirdparty/systemd.git] / src / timesync / timesyncd-manager.c
1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3 /***
4 This file is part of systemd.
5
6 Copyright 2014 Kay Sievers, Lennart Poettering
7
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.
12
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.
17
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/>.
20 ***/
21
22 #include <stdlib.h>
23 #include <errno.h>
24 #include <fcntl.h>
25 #include <unistd.h>
26 #include <string.h>
27 #include <time.h>
28 #include <math.h>
29 #include <arpa/inet.h>
30 #include <netinet/in.h>
31 #include <netinet/ip.h>
32 #include <sys/timerfd.h>
33 #include <sys/timex.h>
34 #include <sys/socket.h>
35 #include <resolv.h>
36 #include <sys/prctl.h>
37 #include <sys/types.h>
38 #include <grp.h>
39
40 #include "missing.h"
41 #include "util.h"
42 #include "sparse-endian.h"
43 #include "log.h"
44 #include "socket-util.h"
45 #include "list.h"
46 #include "ratelimit.h"
47 #include "strv.h"
48 #include "conf-parser.h"
49 #include "sd-daemon.h"
50 #include "event-util.h"
51 #include "network-util.h"
52 #include "clock-util.h"
53 #include "capability.h"
54 #include "mkdir.h"
55 #include "timesyncd-conf.h"
56 #include "timesyncd-manager.h"
57 #include "time-util.h"
58
59 #ifndef ADJ_SETOFFSET
60 #define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
61 #endif
62
63 /* expected accuracy of time synchronization; used to adjust the poll interval */
64 #define NTP_ACCURACY_SEC 0.2
65
66 /*
67 * "A client MUST NOT under any conditions use a poll interval less
68 * than 15 seconds."
69 */
70 #define NTP_POLL_INTERVAL_MIN_SEC 32
71 #define NTP_POLL_INTERVAL_MAX_SEC 2048
72
73 /*
74 * Maximum delta in seconds which the system clock is gradually adjusted
75 * (slew) to approach the network time. Deltas larger that this are set by
76 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
77 */
78 #define NTP_MAX_ADJUST 0.4
79
80 /* NTP protocol, packet header */
81 #define NTP_LEAP_PLUSSEC 1
82 #define NTP_LEAP_MINUSSEC 2
83 #define NTP_LEAP_NOTINSYNC 3
84 #define NTP_MODE_CLIENT 3
85 #define NTP_MODE_SERVER 4
86 #define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
87 #define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
88 #define NTP_FIELD_MODE(f) ((f) & 7)
89 #define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
90
91 /* Maximum acceptable root distance in seconds. */
92 #define NTP_MAX_ROOT_DISTANCE 5.0
93
94 /* Maximum number of missed replies before selecting another source. */
95 #define NTP_MAX_MISSED_REPLIES 2
96
97 /*
98 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
99 * in seconds relative to 0h on 1 January 1900."
100 */
101 #define OFFSET_1900_1970 2208988800UL
102
103 #define RETRY_USEC (30*USEC_PER_SEC)
104 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
105 #define RATELIMIT_BURST 10
106
107 #define TIMEOUT_USEC (10*USEC_PER_SEC)
108
109 struct ntp_ts {
110 be32_t sec;
111 be32_t frac;
112 } _packed_;
113
114 struct ntp_ts_short {
115 be16_t sec;
116 be16_t frac;
117 } _packed_;
118
119 struct ntp_msg {
120 uint8_t field;
121 uint8_t stratum;
122 int8_t poll;
123 int8_t precision;
124 struct ntp_ts_short root_delay;
125 struct ntp_ts_short root_dispersion;
126 char refid[4];
127 struct ntp_ts reference_time;
128 struct ntp_ts origin_time;
129 struct ntp_ts recv_time;
130 struct ntp_ts trans_time;
131 } _packed_;
132
133 static int manager_arm_timer(Manager *m, usec_t next);
134 static int manager_clock_watch_setup(Manager *m);
135 static int manager_listen_setup(Manager *m);
136
137 static double ntp_ts_short_to_d(const struct ntp_ts_short *ts) {
138 return be16toh(ts->sec) + (be16toh(ts->frac) / 65536.0);
139 }
140
141 static double ntp_ts_to_d(const struct ntp_ts *ts) {
142 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
143 }
144
145 static double ts_to_d(const struct timespec *ts) {
146 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
147 }
148
149 static double square(double d) {
150 return d * d;
151 }
152
153 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
154 _cleanup_free_ char *pretty = NULL;
155 Manager *m = userdata;
156
157 assert(m);
158 assert(m->current_server_name);
159 assert(m->current_server_address);
160
161 server_address_pretty(m->current_server_address, &pretty);
162 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
163
164 return manager_connect(m);
165 }
166
167 static int manager_send_request(Manager *m) {
168 _cleanup_free_ char *pretty = NULL;
169 struct ntp_msg ntpmsg = {
170 /*
171 * "The client initializes the NTP message header, sends the request
172 * to the server, and strips the time of day from the Transmit
173 * Timestamp field of the reply. For this purpose, all the NTP
174 * header fields are set to 0, except the Mode, VN, and optional
175 * Transmit Timestamp fields."
176 */
177 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
178 };
179 ssize_t len;
180 int r;
181
182 assert(m);
183 assert(m->current_server_name);
184 assert(m->current_server_address);
185
186 m->event_timeout = sd_event_source_unref(m->event_timeout);
187
188 if (m->server_socket < 0) {
189 r = manager_listen_setup(m);
190 if (r < 0) {
191 log_warning_errno(r, "Failed to setup connection socket: %m");
192 return r;
193 }
194 }
195
196 /*
197 * Set transmit timestamp, remember it; the server will send that back
198 * as the origin timestamp and we have an indication that this is the
199 * matching answer to our request.
200 *
201 * The actual value does not matter, We do not care about the correct
202 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
203 */
204 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
205 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
206 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
207 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
208
209 server_address_pretty(m->current_server_address, &pretty);
210
211 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
212 if (len == sizeof(ntpmsg)) {
213 m->pending = true;
214 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
215 } else {
216 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
217 return manager_connect(m);
218 }
219
220 /* re-arm timer with increasing timeout, in case the packets never arrive back */
221 if (m->retry_interval > 0) {
222 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
223 m->retry_interval *= 2;
224 } else
225 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
226
227 r = manager_arm_timer(m, m->retry_interval);
228 if (r < 0) {
229 log_error_errno(r, "Failed to rearm timer: %m");
230 return r;
231 }
232
233 m->missed_replies++;
234 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
235 r = sd_event_add_time(
236 m->event,
237 &m->event_timeout,
238 clock_boottime_or_monotonic(),
239 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
240 manager_timeout, m);
241 if (r < 0) {
242 log_error_errno(r, "Failed to arm timeout timer: %m");
243 return r;
244 }
245 }
246
247 return 0;
248 }
249
250 static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
251 Manager *m = userdata;
252
253 assert(m);
254
255 return manager_send_request(m);
256 }
257
258 static int manager_arm_timer(Manager *m, usec_t next) {
259 int r;
260
261 assert(m);
262
263 if (next == 0) {
264 m->event_timer = sd_event_source_unref(m->event_timer);
265 return 0;
266 }
267
268 if (m->event_timer) {
269 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
270 if (r < 0)
271 return r;
272
273 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
274 }
275
276 return sd_event_add_time(
277 m->event,
278 &m->event_timer,
279 clock_boottime_or_monotonic(),
280 now(clock_boottime_or_monotonic()) + next, 0,
281 manager_timer, m);
282 }
283
284 static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
285 Manager *m = userdata;
286
287 assert(m);
288
289 /* rearm timer */
290 manager_clock_watch_setup(m);
291
292 /* skip our own jumps */
293 if (m->jumped) {
294 m->jumped = false;
295 return 0;
296 }
297
298 /* resync */
299 log_info("System time changed. Resyncing.");
300 m->poll_resync = true;
301
302 return manager_send_request(m);
303 }
304
305 /* wake up when the system time changes underneath us */
306 static int manager_clock_watch_setup(Manager *m) {
307
308 struct itimerspec its = {
309 .it_value.tv_sec = TIME_T_MAX
310 };
311
312 int r;
313
314 assert(m);
315
316 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
317 safe_close(m->clock_watch_fd);
318
319 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
320 if (m->clock_watch_fd < 0) {
321 log_error("Failed to create timerfd: %m");
322 return -errno;
323 }
324
325 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0) {
326 log_error("Failed to set up timerfd: %m");
327 return -errno;
328 }
329
330 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
331 if (r < 0) {
332 log_error_errno(r, "Failed to create clock watch event source: %m");
333 return r;
334 }
335
336 return 0;
337 }
338
339 static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
340 struct timex tmx = {};
341 int r;
342
343 assert(m);
344
345 /*
346 * For small deltas, tell the kernel to gradually adjust the system
347 * clock to the NTP time, larger deltas are just directly set.
348 */
349 if (fabs(offset) < NTP_MAX_ADJUST) {
350 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
351 tmx.status = STA_PLL;
352 tmx.offset = offset * NSEC_PER_SEC;
353 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
354 tmx.maxerror = 0;
355 tmx.esterror = 0;
356 log_debug(" adjust (slew): %+.3f sec\n", offset);
357 } else {
358 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
359
360 /* ADJ_NANO uses nanoseconds in the microseconds field */
361 tmx.time.tv_sec = (long)offset;
362 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
363
364 /* the kernel expects -0.3s as {-1, 7000.000.000} */
365 if (tmx.time.tv_usec < 0) {
366 tmx.time.tv_sec -= 1;
367 tmx.time.tv_usec += NSEC_PER_SEC;
368 }
369
370 m->jumped = true;
371 log_debug(" adjust (jump): %+.3f sec\n", offset);
372 }
373
374 /*
375 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
376 * which syncs the system time periodically to the RTC.
377 *
378 * In case the RTC runs in local time, never touch the RTC,
379 * we have no way to properly handle daylight saving changes and
380 * mobile devices moving between time zones.
381 */
382 if (m->rtc_local_time)
383 tmx.status |= STA_UNSYNC;
384
385 switch (leap_sec) {
386 case 1:
387 tmx.status |= STA_INS;
388 break;
389 case -1:
390 tmx.status |= STA_DEL;
391 break;
392 }
393
394 r = clock_adjtime(CLOCK_REALTIME, &tmx);
395 if (r < 0)
396 return r;
397
398 touch("/var/lib/systemd/clock");
399
400 m->drift_ppm = tmx.freq / 65536;
401
402 log_debug(" status : %04i %s\n"
403 " time now : %li.%03llu\n"
404 " constant : %li\n"
405 " offset : %+.3f sec\n"
406 " freq offset : %+li (%i ppm)\n",
407 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
408 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
409 tmx.constant,
410 (double)tmx.offset / NSEC_PER_SEC,
411 tmx.freq, m->drift_ppm);
412
413 return 0;
414 }
415
416 static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
417 unsigned int i, idx_cur, idx_new, idx_min;
418 double jitter;
419 double j;
420
421 assert(m);
422
423 m->packet_count++;
424
425 /* ignore initial sample */
426 if (m->packet_count == 1)
427 return false;
428
429 /* store the current data in our samples array */
430 idx_cur = m->samples_idx;
431 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
432 m->samples_idx = idx_new;
433 m->samples[idx_new].offset = offset;
434 m->samples[idx_new].delay = delay;
435
436 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
437 jitter = m->samples_jitter;
438 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
439 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
440 idx_min = i;
441
442 j = 0;
443 for (i = 0; i < ELEMENTSOF(m->samples); i++)
444 j += square(m->samples[i].offset - m->samples[idx_min].offset);
445 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
446
447 /* ignore samples when resyncing */
448 if (m->poll_resync)
449 return false;
450
451 /* always accept offset if we are farther off than the round-trip delay */
452 if (fabs(offset) > delay)
453 return false;
454
455 /* we need a few samples before looking at them */
456 if (m->packet_count < 4)
457 return false;
458
459 /* do not accept anything worse than the maximum possible error of the best sample */
460 if (fabs(offset) > m->samples[idx_min].delay)
461 return true;
462
463 /* compare the difference between the current offset to the previous offset and jitter */
464 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
465 }
466
467 static void manager_adjust_poll(Manager *m, double offset, bool spike) {
468 assert(m);
469
470 if (m->poll_resync) {
471 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
472 m->poll_resync = false;
473 return;
474 }
475
476 /* set to minimal poll interval */
477 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
478 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
479 return;
480 }
481
482 /* increase polling interval */
483 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
484 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
485 m->poll_interval_usec *= 2;
486 return;
487 }
488
489 /* decrease polling interval */
490 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
491 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
492 m->poll_interval_usec /= 2;
493 return;
494 }
495 }
496
497 static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
498 Manager *m = userdata;
499 struct ntp_msg ntpmsg;
500
501 struct iovec iov = {
502 .iov_base = &ntpmsg,
503 .iov_len = sizeof(ntpmsg),
504 };
505 union {
506 struct cmsghdr cmsghdr;
507 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
508 } control;
509 union sockaddr_union server_addr;
510 struct msghdr msghdr = {
511 .msg_iov = &iov,
512 .msg_iovlen = 1,
513 .msg_control = &control,
514 .msg_controllen = sizeof(control),
515 .msg_name = &server_addr,
516 .msg_namelen = sizeof(server_addr),
517 };
518 struct cmsghdr *cmsg;
519 struct timespec *recv_time;
520 ssize_t len;
521 double origin, receive, trans, dest;
522 double delay, offset;
523 double root_distance;
524 bool spike;
525 int leap_sec;
526 int r;
527
528 assert(source);
529 assert(m);
530
531 if (revents & (EPOLLHUP|EPOLLERR)) {
532 log_warning("Server connection returned error.");
533 return manager_connect(m);
534 }
535
536 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
537 if (len < 0) {
538 if (errno == EAGAIN)
539 return 0;
540
541 log_warning("Error receiving message. Disconnecting.");
542 return manager_connect(m);
543 }
544
545 if (iov.iov_len < sizeof(struct ntp_msg)) {
546 log_warning("Invalid response from server. Disconnecting.");
547 return manager_connect(m);
548 }
549
550 if (!m->current_server_name ||
551 !m->current_server_address ||
552 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
553 log_debug("Response from unknown server.");
554 return 0;
555 }
556
557 recv_time = NULL;
558 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
559 if (cmsg->cmsg_level != SOL_SOCKET)
560 continue;
561
562 switch (cmsg->cmsg_type) {
563 case SCM_TIMESTAMPNS:
564 recv_time = (struct timespec *) CMSG_DATA(cmsg);
565 break;
566 }
567 }
568 if (!recv_time) {
569 log_error("Invalid packet timestamp.");
570 return -EINVAL;
571 }
572
573 if (!m->pending) {
574 log_debug("Unexpected reply. Ignoring.");
575 return 0;
576 }
577
578 m->missed_replies = 0;
579
580 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
581 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
582 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
583 log_debug("Invalid reply; not our transmit time. Ignoring.");
584 return 0;
585 }
586
587 m->event_timeout = sd_event_source_unref(m->event_timeout);
588
589 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
590 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
591 log_debug("Invalid reply, returned times before epoch. Ignoring.");
592 return manager_connect(m);
593 }
594
595 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
596 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
597 log_debug("Server is not synchronized. Disconnecting.");
598 return manager_connect(m);
599 }
600
601 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
602 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
603 return manager_connect(m);
604 }
605
606 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
607 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
608 return manager_connect(m);
609 }
610
611 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
612 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
613 log_debug("Server has too large root distance. Disconnecting.");
614 return manager_connect(m);
615 }
616
617 /* valid packet */
618 m->pending = false;
619 m->retry_interval = 0;
620
621 /* Stop listening */
622 m->event_receive = sd_event_source_unref(m->event_receive);
623 m->server_socket = safe_close(m->server_socket);
624
625 /* announce leap seconds */
626 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
627 leap_sec = 1;
628 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
629 leap_sec = -1;
630 else
631 leap_sec = 0;
632
633 /*
634 * "Timestamp Name ID When Generated
635 * ------------------------------------------------------------
636 * Originate Timestamp T1 time request sent by client
637 * Receive Timestamp T2 time request received by server
638 * Transmit Timestamp T3 time reply sent by server
639 * Destination Timestamp T4 time reply received by client
640 *
641 * The round-trip delay, d, and system clock offset, t, are defined as:
642 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
643 */
644 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
645 receive = ntp_ts_to_d(&ntpmsg.recv_time);
646 trans = ntp_ts_to_d(&ntpmsg.trans_time);
647 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
648
649 offset = ((receive - origin) + (trans - dest)) / 2;
650 delay = (dest - origin) - (trans - receive);
651
652 spike = manager_sample_spike_detection(m, offset, delay);
653
654 manager_adjust_poll(m, offset, spike);
655
656 log_debug("NTP response:\n"
657 " leap : %u\n"
658 " version : %u\n"
659 " mode : %u\n"
660 " stratum : %u\n"
661 " precision : %.6f sec (%d)\n"
662 " root distance: %.6f sec\n"
663 " reference : %.4s\n"
664 " origin : %.3f\n"
665 " receive : %.3f\n"
666 " transmit : %.3f\n"
667 " dest : %.3f\n"
668 " offset : %+.3f sec\n"
669 " delay : %+.3f sec\n"
670 " packet count : %"PRIu64"\n"
671 " jitter : %.3f%s\n"
672 " poll interval: " USEC_FMT "\n",
673 NTP_FIELD_LEAP(ntpmsg.field),
674 NTP_FIELD_VERSION(ntpmsg.field),
675 NTP_FIELD_MODE(ntpmsg.field),
676 ntpmsg.stratum,
677 exp2(ntpmsg.precision), ntpmsg.precision,
678 root_distance,
679 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
680 origin - OFFSET_1900_1970,
681 receive - OFFSET_1900_1970,
682 trans - OFFSET_1900_1970,
683 dest - OFFSET_1900_1970,
684 offset, delay,
685 m->packet_count,
686 m->samples_jitter, spike ? " spike" : "",
687 m->poll_interval_usec / USEC_PER_SEC);
688
689 if (!spike) {
690 m->sync = true;
691 r = manager_adjust_clock(m, offset, leap_sec);
692 if (r < 0)
693 log_error("Failed to call clock_adjtime(): %m");
694 }
695
696 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
697 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
698 spike ? " (ignored)" : "");
699
700 r = manager_arm_timer(m, m->poll_interval_usec);
701 if (r < 0) {
702 log_error_errno(r, "Failed to rearm timer: %m");
703 return r;
704 }
705
706 return 0;
707 }
708
709 static int manager_listen_setup(Manager *m) {
710 union sockaddr_union addr = {};
711 static const int tos = IPTOS_LOWDELAY;
712 static const int on = 1;
713 int r;
714
715 assert(m);
716
717 assert(m->server_socket < 0);
718 assert(!m->event_receive);
719 assert(m->current_server_address);
720
721 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
722
723 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
724 if (m->server_socket < 0)
725 return -errno;
726
727 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
728 if (r < 0)
729 return -errno;
730
731 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
732 if (r < 0)
733 return -errno;
734
735 (void) setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
736
737 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
738 }
739
740 static int manager_begin(Manager *m) {
741 _cleanup_free_ char *pretty = NULL;
742 int r;
743
744 assert(m);
745 assert_return(m->current_server_name, -EHOSTUNREACH);
746 assert_return(m->current_server_address, -EHOSTUNREACH);
747
748 m->missed_replies = NTP_MAX_MISSED_REPLIES;
749 if (m->poll_interval_usec == 0)
750 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
751
752 server_address_pretty(m->current_server_address, &pretty);
753 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
754 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
755
756 r = manager_clock_watch_setup(m);
757 if (r < 0)
758 return r;
759
760 return manager_send_request(m);
761 }
762
763 void manager_set_server_name(Manager *m, ServerName *n) {
764 assert(m);
765
766 if (m->current_server_name == n)
767 return;
768
769 m->current_server_name = n;
770 m->current_server_address = NULL;
771
772 manager_disconnect(m);
773
774 if (n)
775 log_debug("Selected server %s.", n->string);
776 }
777
778 void manager_set_server_address(Manager *m, ServerAddress *a) {
779 assert(m);
780
781 if (m->current_server_address == a)
782 return;
783
784 m->current_server_address = a;
785 /* If a is NULL, we are just clearing the address, without
786 * changing the name. Keep the existing name in that case. */
787 if (a)
788 m->current_server_name = a->name;
789
790 manager_disconnect(m);
791
792 if (a) {
793 _cleanup_free_ char *pretty = NULL;
794 server_address_pretty(a, &pretty);
795 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
796 }
797 }
798
799 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
800 Manager *m = userdata;
801 int r;
802
803 assert(q);
804 assert(m);
805 assert(m->current_server_name);
806
807 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
808
809 if (ret != 0) {
810 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
811
812 /* Try next host */
813 return manager_connect(m);
814 }
815
816 for (; ai; ai = ai->ai_next) {
817 _cleanup_free_ char *pretty = NULL;
818 ServerAddress *a;
819
820 assert(ai->ai_addr);
821 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
822
823 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
824 log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
825 continue;
826 }
827
828 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
829 if (r < 0) {
830 log_error_errno(r, "Failed to add server address: %m");
831 return r;
832 }
833
834 server_address_pretty(a, &pretty);
835 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
836 }
837
838 if (!m->current_server_name->addresses) {
839 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
840
841 /* Try next host */
842 return manager_connect(m);
843 }
844
845 manager_set_server_address(m, m->current_server_name->addresses);
846
847 return manager_begin(m);
848 }
849
850 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
851 Manager *m = userdata;
852
853 assert(m);
854
855 return manager_connect(m);
856 }
857
858 int manager_connect(Manager *m) {
859 int r;
860
861 assert(m);
862
863 manager_disconnect(m);
864
865 m->event_retry = sd_event_source_unref(m->event_retry);
866 if (!ratelimit_test(&m->ratelimit)) {
867 log_debug("Slowing down attempts to contact servers.");
868
869 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);
870 if (r < 0) {
871 log_error_errno(r, "Failed to create retry timer: %m");
872 return r;
873 }
874
875 return 0;
876 }
877
878 /* If we already are operating on some address, switch to the
879 * next one. */
880 if (m->current_server_address && m->current_server_address->addresses_next)
881 manager_set_server_address(m, m->current_server_address->addresses_next);
882 else {
883 struct addrinfo hints = {
884 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
885 .ai_socktype = SOCK_DGRAM,
886 };
887
888 /* Hmm, we are through all addresses, let's look for the next host instead */
889 if (m->current_server_name && m->current_server_name->names_next)
890 manager_set_server_name(m, m->current_server_name->names_next);
891 else {
892 ServerName *f;
893 bool restart = true;
894
895 /* Our current server name list is exhausted,
896 * let's find the next one to iterate. First
897 * we try the system list, then the link list.
898 * After having processed the link list we
899 * jump back to the system list. However, if
900 * both lists are empty, we change to the
901 * fallback list. */
902 if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
903 f = m->system_servers;
904 if (!f)
905 f = m->link_servers;
906 } else {
907 f = m->link_servers;
908 if (!f)
909 f = m->system_servers;
910 else
911 restart = false;
912 }
913
914 if (!f)
915 f = m->fallback_servers;
916
917 if (!f) {
918 manager_set_server_name(m, NULL);
919 log_debug("No server found.");
920 return 0;
921 }
922
923 if (restart && !m->exhausted_servers && m->poll_interval_usec) {
924 log_debug("Waiting after exhausting servers.");
925 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);
926 if (r < 0) {
927 log_error_errno(r, "Failed to create retry timer: %m");
928 return r;
929 }
930
931 m->exhausted_servers = true;
932
933 /* Increase the polling interval */
934 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
935 m->poll_interval_usec *= 2;
936
937 return 0;
938 }
939
940 m->exhausted_servers = false;
941
942 manager_set_server_name(m, f);
943 }
944
945 /* Tell the resolver to reread /etc/resolv.conf, in
946 * case it changed. */
947 res_init();
948
949 /* Flush out any previously resolved addresses */
950 server_name_flush_addresses(m->current_server_name);
951
952 log_debug("Resolving %s...", m->current_server_name->string);
953
954 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
955 if (r < 0) {
956 log_error_errno(r, "Failed to create resolver: %m");
957 return r;
958 }
959
960 return 1;
961 }
962
963 r = manager_begin(m);
964 if (r < 0)
965 return r;
966
967 return 1;
968 }
969
970 void manager_disconnect(Manager *m) {
971 assert(m);
972
973 m->resolve_query = sd_resolve_query_unref(m->resolve_query);
974
975 m->event_timer = sd_event_source_unref(m->event_timer);
976
977 m->event_receive = sd_event_source_unref(m->event_receive);
978 m->server_socket = safe_close(m->server_socket);
979
980 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
981 m->clock_watch_fd = safe_close(m->clock_watch_fd);
982
983 m->event_timeout = sd_event_source_unref(m->event_timeout);
984
985 sd_notifyf(false, "STATUS=Idle.");
986 }
987
988 void manager_flush_server_names(Manager *m, ServerType t) {
989 assert(m);
990
991 if (t == SERVER_SYSTEM)
992 while (m->system_servers)
993 server_name_free(m->system_servers);
994
995 if (t == SERVER_LINK)
996 while (m->link_servers)
997 server_name_free(m->link_servers);
998
999 if (t == SERVER_FALLBACK)
1000 while (m->fallback_servers)
1001 server_name_free(m->fallback_servers);
1002 }
1003
1004 void manager_free(Manager *m) {
1005 if (!m)
1006 return;
1007
1008 manager_disconnect(m);
1009 manager_flush_server_names(m, SERVER_SYSTEM);
1010 manager_flush_server_names(m, SERVER_LINK);
1011 manager_flush_server_names(m, SERVER_FALLBACK);
1012
1013 sd_event_source_unref(m->event_retry);
1014
1015 sd_event_source_unref(m->network_event_source);
1016 sd_network_monitor_unref(m->network_monitor);
1017
1018 sd_resolve_unref(m->resolve);
1019 sd_event_unref(m->event);
1020
1021 free(m);
1022 }
1023
1024 static int manager_network_read_link_servers(Manager *m) {
1025 _cleanup_strv_free_ char **ntp = NULL;
1026 ServerName *n, *nx;
1027 char **i;
1028 int r;
1029
1030 assert(m);
1031
1032 r = sd_network_get_ntp(&ntp);
1033 if (r < 0)
1034 goto clear;
1035
1036 LIST_FOREACH(names, n, m->link_servers)
1037 n->marked = true;
1038
1039 STRV_FOREACH(i, ntp) {
1040 bool found = false;
1041
1042 LIST_FOREACH(names, n, m->link_servers)
1043 if (streq(n->string, *i)) {
1044 n->marked = false;
1045 found = true;
1046 break;
1047 }
1048
1049 if (!found) {
1050 r = server_name_new(m, NULL, SERVER_LINK, *i);
1051 if (r < 0)
1052 goto clear;
1053 }
1054 }
1055
1056 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1057 if (n->marked)
1058 server_name_free(n);
1059
1060 return 0;
1061
1062 clear:
1063 manager_flush_server_names(m, SERVER_LINK);
1064 return r;
1065 }
1066
1067 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1068 Manager *m = userdata;
1069 bool connected, online;
1070 int r;
1071
1072 assert(m);
1073
1074 sd_network_monitor_flush(m->network_monitor);
1075
1076 manager_network_read_link_servers(m);
1077
1078 /* check if the machine is online */
1079 online = network_is_online();
1080
1081 /* check if the client is currently connected */
1082 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1083
1084 if (connected && !online) {
1085 log_info("No network connectivity, watching for changes.");
1086 manager_disconnect(m);
1087
1088 } else if (!connected && online) {
1089 log_info("Network configuration changed, trying to establish connection.");
1090
1091 if (m->current_server_address)
1092 r = manager_begin(m);
1093 else
1094 r = manager_connect(m);
1095 if (r < 0)
1096 return r;
1097 }
1098
1099 return 0;
1100 }
1101
1102 static int manager_network_monitor_listen(Manager *m) {
1103 int r, fd, events;
1104
1105 assert(m);
1106
1107 r = sd_network_monitor_new(&m->network_monitor, NULL);
1108 if (r < 0)
1109 return r;
1110
1111 fd = sd_network_monitor_get_fd(m->network_monitor);
1112 if (fd < 0)
1113 return fd;
1114
1115 events = sd_network_monitor_get_events(m->network_monitor);
1116 if (events < 0)
1117 return events;
1118
1119 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1120 if (r < 0)
1121 return r;
1122
1123 return 0;
1124 }
1125
1126 int manager_new(Manager **ret) {
1127 _cleanup_(manager_freep) Manager *m = NULL;
1128 int r;
1129
1130 assert(ret);
1131
1132 m = new0(Manager, 1);
1133 if (!m)
1134 return -ENOMEM;
1135
1136 m->server_socket = m->clock_watch_fd = -1;
1137
1138 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1139
1140 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1141 if (r < 0)
1142 return r;
1143
1144 r = sd_event_default(&m->event);
1145 if (r < 0)
1146 return r;
1147
1148 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1149 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1150
1151 sd_event_set_watchdog(m->event, true);
1152
1153 r = sd_resolve_default(&m->resolve);
1154 if (r < 0)
1155 return r;
1156
1157 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1158 if (r < 0)
1159 return r;
1160
1161 r = manager_network_monitor_listen(m);
1162 if (r < 0)
1163 return r;
1164
1165 manager_network_read_link_servers(m);
1166
1167 *ret = m;
1168 m = NULL;
1169
1170 return 0;
1171 }
Unnamed repository; edit this file 'description' to name the repository.