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