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