]> git.proxmox.com Git - systemd.git/blame - src/timesync/timesyncd-manager.c
projects / systemd.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Imported Upstream version 218
[systemd.git] / src / timesync / timesyncd-manager.c
CommitLineData
5eef597e
MP		 1/*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
2
3/***
4 This file is part of systemd.
5
6 Copyright 2014 Kay Sievers, Lennart Poettering
7
8 systemd is free software; you can redistribute it and/or modify it
9 under the terms of the GNU Lesser General Public License as published by
10 the Free Software Foundation; either version 2.1 of the License, or
11 (at your option) any later version.
12
13 systemd is distributed in the hope that it will be useful, but
14 WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16 Lesser General Public License for more details.
17
18 You should have received a copy of the GNU Lesser General Public License
19 along with systemd; If not, see <http://www.gnu.org/licenses/>.
20***/
21
22#include <stdlib.h>
23#include <errno.h>
24#include <fcntl.h>
25#include <unistd.h>
26#include <string.h>
27#include <time.h>
28#include <math.h>
29#include <arpa/inet.h>
30#include <netinet/in.h>
31#include <netinet/ip.h>
32#include <sys/timerfd.h>
33#include <sys/timex.h>
34#include <sys/socket.h>
35#include <resolv.h>
36#include <sys/prctl.h>
37#include <sys/types.h>
38#include <grp.h>
39
40#include "missing.h"
41#include "util.h"
42#include "sparse-endian.h"
43#include "log.h"
44#include "socket-util.h"
45#include "list.h"
46#include "ratelimit.h"
47#include "strv.h"
48#include "conf-parser.h"
49#include "sd-daemon.h"
50#include "event-util.h"
51#include "network-util.h"
52#include "clock-util.h"
53#include "capability.h"
54#include "mkdir.h"
55#include "timesyncd-conf.h"
56#include "timesyncd-manager.h"
57#include "time-util.h"
58
59#ifndef ADJ_SETOFFSET
60#define ADJ_SETOFFSET 0x0100 /* add 'time' to current time */
61#endif
62
63/* expected accuracy of time synchronization; used to adjust the poll interval */
64#define NTP_ACCURACY_SEC 0.2
65
66/*
67 * "A client MUST NOT under any conditions use a poll interval less
68 * than 15 seconds."
69 */
70#define NTP_POLL_INTERVAL_MIN_SEC 32
71#define NTP_POLL_INTERVAL_MAX_SEC 2048
72
73/*
74 * Maximum delta in seconds which the system clock is gradually adjusted
75 * (slew) to approach the network time. Deltas larger that this are set by
76 * letting the system time jump. The kernel's limit for adjtime is 0.5s.
77 */
78#define NTP_MAX_ADJUST 0.4
79
80/* NTP protocol, packet header */
81#define NTP_LEAP_PLUSSEC 1
82#define NTP_LEAP_MINUSSEC 2
83#define NTP_LEAP_NOTINSYNC 3
84#define NTP_MODE_CLIENT 3
85#define NTP_MODE_SERVER 4
86#define NTP_FIELD_LEAP(f) (((f) >> 6) & 3)
87#define NTP_FIELD_VERSION(f) (((f) >> 3) & 7)
88#define NTP_FIELD_MODE(f) ((f) & 7)
89#define NTP_FIELD(l, v, m) (((l) << 6) | ((v) << 3) | (m))
90
91/* Maximum acceptable root distance in seconds. */
92#define NTP_MAX_ROOT_DISTANCE 5.0
93
94/* Maximum number of missed replies before selecting another source. */
95#define NTP_MAX_MISSED_REPLIES 2
96
97/*
98 * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
99 * in seconds relative to 0h on 1 January 1900."
100 */
101#define OFFSET_1900_1970 2208988800UL
102
103#define RETRY_USEC (30*USEC_PER_SEC)
104#define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
105#define RATELIMIT_BURST 10
106
107#define TIMEOUT_USEC (10*USEC_PER_SEC)
108
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);
f47781d8
MP		 135static int manager_listen_setup(Manager *m);
136static void manager_listen_stop(Manager *m);
5eef597e
MP		 137
138static double ntp_ts_short_to_d(const struct ntp_ts_short *ts) {
139 return be16toh(ts->sec) + (be16toh(ts->frac) / 65536.0);
140}
141
142static double ntp_ts_to_d(const struct ntp_ts *ts) {
143 return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
144}
145
146static double ts_to_d(const struct timespec *ts) {
147 return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
148}
149
150static double square(double d) {
151 return d * d;
152}
153
154static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
155 _cleanup_free_ char *pretty = NULL;
156 Manager *m = userdata;
157
158 assert(m);
159 assert(m->current_server_name);
160 assert(m->current_server_address);
161
162 server_address_pretty(m->current_server_address, &pretty);
163 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
164
165 return manager_connect(m);
166}
167
168static int manager_send_request(Manager *m) {
169 _cleanup_free_ char *pretty = NULL;
170 struct ntp_msg ntpmsg = {
171 /*
172 * "The client initializes the NTP message header, sends the request
173 * to the server, and strips the time of day from the Transmit
174 * Timestamp field of the reply. For this purpose, all the NTP
175 * header fields are set to 0, except the Mode, VN, and optional
176 * Transmit Timestamp fields."
177 */
178 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
179 };
180 ssize_t len;
181 int r;
182
183 assert(m);
184 assert(m->current_server_name);
185 assert(m->current_server_address);
186
187 m->event_timeout = sd_event_source_unref(m->event_timeout);
188
f47781d8
MP		 189 r = manager_listen_setup(m);
190 if (r < 0)
191 return log_warning_errno(r, "Failed to setup connection socket: %m");
192
5eef597e
MP		 193 /*
194 * Set transmit timestamp, remember it; the server will send that back
195 * as the origin timestamp and we have an indication that this is the
196 * matching answer to our request.
197 *
198 * The actual value does not matter, We do not care about the correct
199 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
200 */
201 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
202 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
203 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
204 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
205
206 server_address_pretty(m->current_server_address, &pretty);
207
208 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
209 if (len == sizeof(ntpmsg)) {
210 m->pending = true;
211 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
212 } else {
f47781d8 213 log_debug_errno(errno, "Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
5eef597e
MP		 214 return manager_connect(m);
215 }
216
217 /* re-arm timer with increasing timeout, in case the packets never arrive back */
218 if (m->retry_interval > 0) {
219 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
220 m->retry_interval *= 2;
221 } else
222 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
223
224 r = manager_arm_timer(m, m->retry_interval);
f47781d8
MP		 225 if (r < 0)
226 return log_error_errno(r, "Failed to rearm timer: %m");
5eef597e
MP		 227
228 m->missed_replies++;
229 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
230 r = sd_event_add_time(
231 m->event,
232 &m->event_timeout,
233 clock_boottime_or_monotonic(),
234 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
235 manager_timeout, m);
f47781d8
MP		 236 if (r < 0)
237 return log_error_errno(r, "Failed to arm timeout timer: %m");
5eef597e
MP		 238 }
239
240 return 0;
241}
242
243static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
244 Manager *m = userdata;
245
246 assert(m);
247
248 return manager_send_request(m);
249}
250
251static int manager_arm_timer(Manager *m, usec_t next) {
252 int r;
253
254 assert(m);
5eef597e
MP		 255
256 if (next == 0) {
257 m->event_timer = sd_event_source_unref(m->event_timer);
258 return 0;
259 }
260
261 if (m->event_timer) {
262 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
263 if (r < 0)
264 return r;
265
266 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
267 }
268
269 return sd_event_add_time(
270 m->event,
271 &m->event_timer,
272 clock_boottime_or_monotonic(),
273 now(clock_boottime_or_monotonic()) + next, 0,
274 manager_timer, m);
275}
276
277static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
278 Manager *m = userdata;
279
280 assert(m);
281
282 /* rearm timer */
283 manager_clock_watch_setup(m);
284
285 /* skip our own jumps */
286 if (m->jumped) {
287 m->jumped = false;
288 return 0;
289 }
290
291 /* resync */
292 log_info("System time changed. Resyncing.");
293 m->poll_resync = true;
294
295 return manager_send_request(m);
296}
297
298/* wake up when the system time changes underneath us */
299static int manager_clock_watch_setup(Manager *m) {
300
301 struct itimerspec its = {
302 .it_value.tv_sec = TIME_T_MAX
303 };
304
305 int r;
306
307 assert(m);
308
309 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
310 safe_close(m->clock_watch_fd);
311
312 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
f47781d8
MP		 313 if (m->clock_watch_fd < 0)
314 return log_error_errno(errno, "Failed to create timerfd: %m");
5eef597e 315
f47781d8
MP		 316 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0)
317 return log_error_errno(errno, "Failed to set up timerfd: %m");
5eef597e
MP		 318
319 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
f47781d8
MP		 320 if (r < 0)
321 return log_error_errno(r, "Failed to create clock watch event source: %m");
5eef597e
MP		 322
323 return 0;
324}
325
326static 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;
f47781d8 343 log_debug(" adjust (slew): %+.3f sec", offset);
5eef597e
MP		 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;
f47781d8 358 log_debug(" adjust (jump): %+.3f sec", offset);
5eef597e
MP		 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
403static 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
454static 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
484static 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 m->missed_replies = 0;
566
567 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
568 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
569 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
570 log_debug("Invalid reply; not our transmit time. Ignoring.");
571 return 0;
572 }
573
574 m->event_timeout = sd_event_source_unref(m->event_timeout);
575
576 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
577 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
578 log_debug("Invalid reply, returned times before epoch. Ignoring.");
579 return manager_connect(m);
580 }
581
582 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
583 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
584 log_debug("Server is not synchronized. Disconnecting.");
585 return manager_connect(m);
586 }
587
588 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
589 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
590 return manager_connect(m);
591 }
592
593 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
594 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
595 return manager_connect(m);
596 }
597
598 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
599 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
600 log_debug("Server has too large root distance. Disconnecting.");
601 return manager_connect(m);
602 }
603
604 /* valid packet */
605 m->pending = false;
606 m->retry_interval = 0;
607
f47781d8
MP		 608 /* Stop listening */
609 manager_listen_stop(m);
610
5eef597e
MP		 611 /* announce leap seconds */
612 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
613 leap_sec = 1;
614 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
615 leap_sec = -1;
616 else
617 leap_sec = 0;
618
619 /*
620 * "Timestamp Name ID When Generated
621 * ------------------------------------------------------------
622 * Originate Timestamp T1 time request sent by client
623 * Receive Timestamp T2 time request received by server
624 * Transmit Timestamp T3 time reply sent by server
625 * Destination Timestamp T4 time reply received by client
626 *
627 * The round-trip delay, d, and system clock offset, t, are defined as:
628 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
629 */
630 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
631 receive = ntp_ts_to_d(&ntpmsg.recv_time);
632 trans = ntp_ts_to_d(&ntpmsg.trans_time);
633 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
634
635 offset = ((receive - origin) + (trans - dest)) / 2;
636 delay = (dest - origin) - (trans - receive);
637
638 spike = manager_sample_spike_detection(m, offset, delay);
639
640 manager_adjust_poll(m, offset, spike);
641
642 log_debug("NTP response:\n"
643 " leap : %u\n"
644 " version : %u\n"
645 " mode : %u\n"
646 " stratum : %u\n"
647 " precision : %.6f sec (%d)\n"
648 " root distance: %.6f sec\n"
649 " reference : %.4s\n"
650 " origin : %.3f\n"
651 " receive : %.3f\n"
652 " transmit : %.3f\n"
653 " dest : %.3f\n"
654 " offset : %+.3f sec\n"
655 " delay : %+.3f sec\n"
656 " packet count : %"PRIu64"\n"
657 " jitter : %.3f%s\n"
658 " poll interval: " USEC_FMT "\n",
659 NTP_FIELD_LEAP(ntpmsg.field),
660 NTP_FIELD_VERSION(ntpmsg.field),
661 NTP_FIELD_MODE(ntpmsg.field),
662 ntpmsg.stratum,
663 exp2(ntpmsg.precision), ntpmsg.precision,
664 root_distance,
665 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
666 origin - OFFSET_1900_1970,
667 receive - OFFSET_1900_1970,
668 trans - OFFSET_1900_1970,
669 dest - OFFSET_1900_1970,
670 offset, delay,
671 m->packet_count,
672 m->samples_jitter, spike ? " spike" : "",
673 m->poll_interval_usec / USEC_PER_SEC);
674
675 if (!spike) {
676 m->sync = true;
677 r = manager_adjust_clock(m, offset, leap_sec);
678 if (r < 0)
f47781d8 679 log_error_errno(errno, "Failed to call clock_adjtime(): %m");
5eef597e
MP		 680 }
681
682 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
683 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
684 spike ? " (ignored)" : "");
685
686 r = manager_arm_timer(m, m->poll_interval_usec);
f47781d8
MP		 687 if (r < 0)
688 return log_error_errno(r, "Failed to rearm timer: %m");
5eef597e
MP		 689
690 return 0;
691}
692
693static int manager_listen_setup(Manager *m) {
694 union sockaddr_union addr = {};
695 static const int tos = IPTOS_LOWDELAY;
696 static const int on = 1;
697 int r;
698
699 assert(m);
700
f47781d8
MP		 701 if (m->server_socket >= 0)
702 return 0;
703
5eef597e
MP		 704 assert(!m->event_receive);
705 assert(m->current_server_address);
706
707 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
708
709 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
710 if (m->server_socket < 0)
711 return -errno;
712
713 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
714 if (r < 0)
715 return -errno;
716
717 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
718 if (r < 0)
719 return -errno;
720
721 (void) setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
722
723 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
724}
725
f47781d8
MP		 726static void manager_listen_stop(Manager *m) {
727 assert(m);
728
729 m->event_receive = sd_event_source_unref(m->event_receive);
730 m->server_socket = safe_close(m->server_socket);
731}
732
5eef597e
MP		 733static int manager_begin(Manager *m) {
734 _cleanup_free_ char *pretty = NULL;
735 int r;
736
737 assert(m);
738 assert_return(m->current_server_name, -EHOSTUNREACH);
739 assert_return(m->current_server_address, -EHOSTUNREACH);
740
741 m->missed_replies = NTP_MAX_MISSED_REPLIES;
742 if (m->poll_interval_usec == 0)
743 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
744
745 server_address_pretty(m->current_server_address, &pretty);
746 log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
747 sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
748
5eef597e
MP		 749 r = manager_clock_watch_setup(m);
750 if (r < 0)
751 return r;
752
753 return manager_send_request(m);
754}
755
756void manager_set_server_name(Manager *m, ServerName *n) {
757 assert(m);
758
759 if (m->current_server_name == n)
760 return;
761
762 m->current_server_name = n;
763 m->current_server_address = NULL;
764
765 manager_disconnect(m);
766
767 if (n)
768 log_debug("Selected server %s.", n->string);
769}
770
771void manager_set_server_address(Manager *m, ServerAddress *a) {
772 assert(m);
773
774 if (m->current_server_address == a)
775 return;
776
777 m->current_server_address = a;
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;
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);
789 }
790}
791
792static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
793 Manager *m = userdata;
794 int r;
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
809 for (; ai; ai = ai->ai_next) {
810 _cleanup_free_ char *pretty = NULL;
811 ServerAddress *a;
812
813 assert(ai->ai_addr);
814 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
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
821 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
f47781d8
MP		 822 if (r < 0)
823 return log_error_errno(r, "Failed to add server address: %m");
5eef597e
MP		 824
825 server_address_pretty(a, &pretty);
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
836 manager_set_server_address(m, m->current_server_name->addresses);
837
838 return manager_begin(m);
839}
840
841static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
842 Manager *m = userdata;
843
844 assert(m);
845
846 return manager_connect(m);
847}
848
849int manager_connect(Manager *m) {
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
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);
f47781d8
MP		 861 if (r < 0)
862 return log_error_errno(r, "Failed to create retry timer: %m");
5eef597e
MP		 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)
870 manager_set_server_address(m, m->current_server_address->addresses_next);
871 else {
872 struct addrinfo hints = {
873 .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
874 .ai_socktype = SOCK_DGRAM,
875 };
876
877 /* Hmm, we are through all addresses, let's look for the next host instead */
878 if (m->current_server_name && m->current_server_name->names_next)
879 manager_set_server_name(m, m->current_server_name->names_next);
880 else {
881 ServerName *f;
882 bool restart = true;
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;
899 else
900 restart = false;
901 }
902
903 if (!f)
904 f = m->fallback_servers;
905
906 if (!f) {
907 manager_set_server_name(m, NULL);
908 log_debug("No server found.");
909 return 0;
910 }
911
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);
f47781d8
MP		 915 if (r < 0)
916 return log_error_errno(r, "Failed to create retry timer: %m");
5eef597e
MP		 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
929 manager_set_server_name(m, f);
930 }
931
932 /* Tell the resolver to reread /etc/resolv.conf, in
933 * case it changed. */
934 res_init();
935
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
941 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
f47781d8
MP		 942 if (r < 0)
943 return log_error_errno(r, "Failed to create resolver: %m");
5eef597e
MP		 944
945 return 1;
946 }
947
948 r = manager_begin(m);
949 if (r < 0)
950 return r;
951
952 return 1;
953}
954
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
f47781d8 962 manager_listen_stop(m);
5eef597e
MP		 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
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}
987
988void manager_free(Manager *m) {
989 if (!m)
990 return;
991
992 manager_disconnect(m);
993 manager_flush_server_names(m, SERVER_SYSTEM);
994 manager_flush_server_names(m, SERVER_LINK);
995 manager_flush_server_names(m, SERVER_FALLBACK);
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
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
1014 assert(m);
1015
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;
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
1060 manager_network_read_link_servers(m);
1061
1062 /* check if the machine is online */
1063 online = network_is_online();
1064
1065 /* check if the client is currently connected */
1066 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
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
1124 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
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
1149 manager_network_read_link_servers(m);
1150
1151 *ret = m;
1152 m = NULL;
1153
1154 return 0;
1155}
systemd for Proxmox projects