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