]> 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
nspawn: Allow module loading if CAP_SYS_MODULE is requested
[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);
f89c4e15 136static void manager_listen_stop(Manager *m);
84e51726 137
3af0442c
ML		 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
84e51726
LP		 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
84e51726
LP		 150static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
151 _cleanup_free_ char *pretty = NULL;
152 Manager *m = userdata;
153
154 assert(m);
155 assert(m->current_server_name);
156 assert(m->current_server_address);
157
158 server_address_pretty(m->current_server_address, &pretty);
159 log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
160
161 return manager_connect(m);
162}
163
164static int manager_send_request(Manager *m) {
165 _cleanup_free_ char *pretty = NULL;
166 struct ntp_msg ntpmsg = {
167 /*
168 * "The client initializes the NTP message header, sends the request
169 * to the server, and strips the time of day from the Transmit
170 * Timestamp field of the reply. For this purpose, all the NTP
171 * header fields are set to 0, except the Mode, VN, and optional
172 * Transmit Timestamp fields."
173 */
174 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
175 };
176 ssize_t len;
177 int r;
178
179 assert(m);
180 assert(m->current_server_name);
181 assert(m->current_server_address);
182
183 m->event_timeout = sd_event_source_unref(m->event_timeout);
184
f89c4e15
LP		 185 r = manager_listen_setup(m);
186 if (r < 0)
187 return log_warning_errno(r, "Failed to setup connection socket: %m");
7b628891 188
84e51726
LP		 189 /*
190 * Set transmit timestamp, remember it; the server will send that back
191 * as the origin timestamp and we have an indication that this is the
192 * matching answer to our request.
193 *
194 * The actual value does not matter, We do not care about the correct
195 * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
196 */
197 assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
198 assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
199 ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
200 ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
201
202 server_address_pretty(m->current_server_address, &pretty);
203
204 len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
205 if (len == sizeof(ntpmsg)) {
206 m->pending = true;
207 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
208 } else {
56f64d95 209 log_debug_errno(errno, "Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
84e51726
LP		 210 return manager_connect(m);
211 }
212
ab4df227
KS		 213 /* re-arm timer with increasing timeout, in case the packets never arrive back */
214 if (m->retry_interval > 0) {
215 if (m->retry_interval < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
216 m->retry_interval *= 2;
217 } else
218 m->retry_interval = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
219
220 r = manager_arm_timer(m, m->retry_interval);
f647962d
MS		 221 if (r < 0)
222 return log_error_errno(r, "Failed to rearm timer: %m");
ab4df227 223
e8206972
ML		 224 m->missed_replies++;
225 if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
226 r = sd_event_add_time(
227 m->event,
228 &m->event_timeout,
229 clock_boottime_or_monotonic(),
230 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
231 manager_timeout, m);
f647962d
MS		 232 if (r < 0)
233 return log_error_errno(r, "Failed to arm timeout timer: %m");
84e51726
LP		 234 }
235
236 return 0;
237}
238
239static int manager_timer(sd_event_source *source, usec_t usec, void *userdata) {
240 Manager *m = userdata;
241
242 assert(m);
243
244 return manager_send_request(m);
245}
246
247static int manager_arm_timer(Manager *m, usec_t next) {
248 int r;
249
250 assert(m);
84e51726
LP		 251
252 if (next == 0) {
253 m->event_timer = sd_event_source_unref(m->event_timer);
254 return 0;
255 }
256
257 if (m->event_timer) {
258 r = sd_event_source_set_time(m->event_timer, now(clock_boottime_or_monotonic()) + next);
259 if (r < 0)
260 return r;
261
262 return sd_event_source_set_enabled(m->event_timer, SD_EVENT_ONESHOT);
263 }
264
265 return sd_event_add_time(
266 m->event,
267 &m->event_timer,
268 clock_boottime_or_monotonic(),
269 now(clock_boottime_or_monotonic()) + next, 0,
270 manager_timer, m);
271}
272
273static int manager_clock_watch(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
274 Manager *m = userdata;
275
276 assert(m);
277
278 /* rearm timer */
279 manager_clock_watch_setup(m);
280
281 /* skip our own jumps */
282 if (m->jumped) {
283 m->jumped = false;
284 return 0;
285 }
286
287 /* resync */
288 log_info("System time changed. Resyncing.");
289 m->poll_resync = true;
290
291 return manager_send_request(m);
292}
293
294/* wake up when the system time changes underneath us */
295static int manager_clock_watch_setup(Manager *m) {
296
297 struct itimerspec its = {
298 .it_value.tv_sec = TIME_T_MAX
299 };
300
301 int r;
302
303 assert(m);
304
305 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
306 safe_close(m->clock_watch_fd);
307
308 m->clock_watch_fd = timerfd_create(CLOCK_REALTIME, TFD_NONBLOCK|TFD_CLOEXEC);
4a62c710
MS		 309 if (m->clock_watch_fd < 0)
310 return log_error_errno(errno, "Failed to create timerfd: %m");
84e51726 311
4a62c710
MS		 312 if (timerfd_settime(m->clock_watch_fd, TFD_TIMER_ABSTIME|TFD_TIMER_CANCEL_ON_SET, &its, NULL) < 0)
313 return log_error_errno(errno, "Failed to set up timerfd: %m");
84e51726
LP		 314
315 r = sd_event_add_io(m->event, &m->event_clock_watch, m->clock_watch_fd, EPOLLIN, manager_clock_watch, m);
f647962d
MS		 316 if (r < 0)
317 return log_error_errno(r, "Failed to create clock watch event source: %m");
84e51726
LP		 318
319 return 0;
320}
321
322static int manager_adjust_clock(Manager *m, double offset, int leap_sec) {
323 struct timex tmx = {};
324 int r;
325
326 assert(m);
327
328 /*
329 * For small deltas, tell the kernel to gradually adjust the system
330 * clock to the NTP time, larger deltas are just directly set.
331 */
332 if (fabs(offset) < NTP_MAX_ADJUST) {
333 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_OFFSET | ADJ_TIMECONST | ADJ_MAXERROR | ADJ_ESTERROR;
334 tmx.status = STA_PLL;
335 tmx.offset = offset * NSEC_PER_SEC;
336 tmx.constant = log2i(m->poll_interval_usec / USEC_PER_SEC) - 4;
337 tmx.maxerror = 0;
338 tmx.esterror = 0;
ff49bc32 339 log_debug(" adjust (slew): %+.3f sec", offset);
84e51726
LP		 340 } else {
341 tmx.modes = ADJ_STATUS | ADJ_NANO | ADJ_SETOFFSET;
342
343 /* ADJ_NANO uses nanoseconds in the microseconds field */
344 tmx.time.tv_sec = (long)offset;
345 tmx.time.tv_usec = (offset - tmx.time.tv_sec) * NSEC_PER_SEC;
346
347 /* the kernel expects -0.3s as {-1, 7000.000.000} */
348 if (tmx.time.tv_usec < 0) {
349 tmx.time.tv_sec -= 1;
350 tmx.time.tv_usec += NSEC_PER_SEC;
351 }
352
353 m->jumped = true;
ff49bc32 354 log_debug(" adjust (jump): %+.3f sec", offset);
84e51726
LP		 355 }
356
357 /*
358 * An unset STA_UNSYNC will enable the kernel's 11-minute mode,
359 * which syncs the system time periodically to the RTC.
360 *
361 * In case the RTC runs in local time, never touch the RTC,
362 * we have no way to properly handle daylight saving changes and
363 * mobile devices moving between time zones.
364 */
365 if (m->rtc_local_time)
366 tmx.status |= STA_UNSYNC;
367
368 switch (leap_sec) {
369 case 1:
370 tmx.status |= STA_INS;
371 break;
372 case -1:
373 tmx.status |= STA_DEL;
374 break;
375 }
376
377 r = clock_adjtime(CLOCK_REALTIME, &tmx);
378 if (r < 0)
379 return r;
380
381 touch("/var/lib/systemd/clock");
382
383 m->drift_ppm = tmx.freq / 65536;
384
385 log_debug(" status : %04i %s\n"
386 " time now : %li.%03llu\n"
387 " constant : %li\n"
388 " offset : %+.3f sec\n"
389 " freq offset : %+li (%i ppm)\n",
390 tmx.status, tmx.status & STA_UNSYNC ? "unsync" : "sync",
391 tmx.time.tv_sec, (unsigned long long) (tmx.time.tv_usec / NSEC_PER_MSEC),
392 tmx.constant,
393 (double)tmx.offset / NSEC_PER_SEC,
394 tmx.freq, m->drift_ppm);
395
396 return 0;
397}
398
399static bool manager_sample_spike_detection(Manager *m, double offset, double delay) {
400 unsigned int i, idx_cur, idx_new, idx_min;
401 double jitter;
402 double j;
403
404 assert(m);
405
406 m->packet_count++;
407
408 /* ignore initial sample */
409 if (m->packet_count == 1)
410 return false;
411
412 /* store the current data in our samples array */
413 idx_cur = m->samples_idx;
414 idx_new = (idx_cur + 1) % ELEMENTSOF(m->samples);
415 m->samples_idx = idx_new;
416 m->samples[idx_new].offset = offset;
417 m->samples[idx_new].delay = delay;
418
419 /* calculate new jitter value from the RMS differences relative to the lowest delay sample */
420 jitter = m->samples_jitter;
421 for (idx_min = idx_cur, i = 0; i < ELEMENTSOF(m->samples); i++)
422 if (m->samples[i].delay > 0 && m->samples[i].delay < m->samples[idx_min].delay)
423 idx_min = i;
424
425 j = 0;
426 for (i = 0; i < ELEMENTSOF(m->samples); i++)
fa66b606 427 j += pow(m->samples[i].offset - m->samples[idx_min].offset, 2);
84e51726
LP		 428 m->samples_jitter = sqrt(j / (ELEMENTSOF(m->samples) - 1));
429
430 /* ignore samples when resyncing */
431 if (m->poll_resync)
432 return false;
433
434 /* always accept offset if we are farther off than the round-trip delay */
435 if (fabs(offset) > delay)
436 return false;
437
438 /* we need a few samples before looking at them */
439 if (m->packet_count < 4)
440 return false;
441
442 /* do not accept anything worse than the maximum possible error of the best sample */
443 if (fabs(offset) > m->samples[idx_min].delay)
444 return true;
445
446 /* compare the difference between the current offset to the previous offset and jitter */
447 return fabs(offset - m->samples[idx_cur].offset) > 3 * jitter;
448}
449
450static void manager_adjust_poll(Manager *m, double offset, bool spike) {
451 assert(m);
452
453 if (m->poll_resync) {
454 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
455 m->poll_resync = false;
456 return;
457 }
458
459 /* set to minimal poll interval */
460 if (!spike && fabs(offset) > NTP_ACCURACY_SEC) {
461 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
462 return;
463 }
464
465 /* increase polling interval */
466 if (fabs(offset) < NTP_ACCURACY_SEC * 0.25) {
467 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
468 m->poll_interval_usec *= 2;
469 return;
470 }
471
472 /* decrease polling interval */
473 if (spike || fabs(offset) > NTP_ACCURACY_SEC * 0.75) {
474 if (m->poll_interval_usec > NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC)
475 m->poll_interval_usec /= 2;
476 return;
477 }
478}
479
480static int manager_receive_response(sd_event_source *source, int fd, uint32_t revents, void *userdata) {
481 Manager *m = userdata;
482 struct ntp_msg ntpmsg;
483
484 struct iovec iov = {
485 .iov_base = &ntpmsg,
486 .iov_len = sizeof(ntpmsg),
487 };
488 union {
489 struct cmsghdr cmsghdr;
490 uint8_t buf[CMSG_SPACE(sizeof(struct timeval))];
491 } control;
492 union sockaddr_union server_addr;
493 struct msghdr msghdr = {
494 .msg_iov = &iov,
495 .msg_iovlen = 1,
496 .msg_control = &control,
497 .msg_controllen = sizeof(control),
498 .msg_name = &server_addr,
499 .msg_namelen = sizeof(server_addr),
500 };
501 struct cmsghdr *cmsg;
487a3682 502 struct timespec *recv_time;
84e51726
LP		 503 ssize_t len;
504 double origin, receive, trans, dest;
505 double delay, offset;
3af0442c 506 double root_distance;
84e51726
LP		 507 bool spike;
508 int leap_sec;
509 int r;
510
511 assert(source);
512 assert(m);
513
514 if (revents & (EPOLLHUP|EPOLLERR)) {
515 log_warning("Server connection returned error.");
516 return manager_connect(m);
517 }
518
519 len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
520 if (len < 0) {
521 if (errno == EAGAIN)
522 return 0;
523
524 log_warning("Error receiving message. Disconnecting.");
525 return manager_connect(m);
526 }
527
43fcd650
TM		 528 /* Too short or too long packet? */
529 if (iov.iov_len < sizeof(struct ntp_msg) || (msghdr.msg_flags & MSG_TRUNC)) {
84e51726
LP		 530 log_warning("Invalid response from server. Disconnecting.");
531 return manager_connect(m);
532 }
533
534 if (!m->current_server_name ||
535 !m->current_server_address ||
536 !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
537 log_debug("Response from unknown server.");
538 return 0;
539 }
540
541 recv_time = NULL;
542 for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
543 if (cmsg->cmsg_level != SOL_SOCKET)
544 continue;
545
546 switch (cmsg->cmsg_type) {
487a3682
ML		 547 case SCM_TIMESTAMPNS:
548 recv_time = (struct timespec *) CMSG_DATA(cmsg);
84e51726
LP		 549 break;
550 }
551 }
552 if (!recv_time) {
553 log_error("Invalid packet timestamp.");
554 return -EINVAL;
555 }
556
557 if (!m->pending) {
558 log_debug("Unexpected reply. Ignoring.");
559 return 0;
560 }
561
e8206972
ML		 562 m->missed_replies = 0;
563
84e51726
LP		 564 /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
565 if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
566 be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
567 log_debug("Invalid reply; not our transmit time. Ignoring.");
568 return 0;
569 }
570
571 m->event_timeout = sd_event_source_unref(m->event_timeout);
572
573 if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
574 be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
575 log_debug("Invalid reply, returned times before epoch. Ignoring.");
576 return manager_connect(m);
577 }
578
07610e10
ML		 579 if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
580 ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
84e51726
LP		 581 log_debug("Server is not synchronized. Disconnecting.");
582 return manager_connect(m);
583 }
584
585 if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
586 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
587 return manager_connect(m);
588 }
589
590 if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
591 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
592 return manager_connect(m);
593 }
594
3af0442c
ML		 595 root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
596 if (root_distance > NTP_MAX_ROOT_DISTANCE) {
597 log_debug("Server has too large root distance. Disconnecting.");
598 return manager_connect(m);
599 }
600
84e51726
LP		 601 /* valid packet */
602 m->pending = false;
ab4df227 603 m->retry_interval = 0;
84e51726 604
7b628891 605 /* Stop listening */
f89c4e15 606 manager_listen_stop(m);
7b628891 607
84e51726
LP		 608 /* announce leap seconds */
609 if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
610 leap_sec = 1;
611 else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
612 leap_sec = -1;
613 else
614 leap_sec = 0;
615
616 /*
617 * "Timestamp Name ID When Generated
618 * ------------------------------------------------------------
619 * Originate Timestamp T1 time request sent by client
620 * Receive Timestamp T2 time request received by server
621 * Transmit Timestamp T3 time reply sent by server
622 * Destination Timestamp T4 time reply received by client
623 *
624 * The round-trip delay, d, and system clock offset, t, are defined as:
625 * d = (T4 - T1) - (T3 - T2) t = ((T2 - T1) + (T3 - T4)) / 2"
626 */
73c76e63 627 origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
84e51726
LP		 628 receive = ntp_ts_to_d(&ntpmsg.recv_time);
629 trans = ntp_ts_to_d(&ntpmsg.trans_time);
487a3682 630 dest = ts_to_d(recv_time) + OFFSET_1900_1970;
84e51726
LP		 631
632 offset = ((receive - origin) + (trans - dest)) / 2;
633 delay = (dest - origin) - (trans - receive);
634
635 spike = manager_sample_spike_detection(m, offset, delay);
636
637 manager_adjust_poll(m, offset, spike);
638
639 log_debug("NTP response:\n"
640 " leap : %u\n"
641 " version : %u\n"
642 " mode : %u\n"
643 " stratum : %u\n"
644 " precision : %.6f sec (%d)\n"
3af0442c 645 " root distance: %.6f sec\n"
84e51726
LP		 646 " reference : %.4s\n"
647 " origin : %.3f\n"
648 " receive : %.3f\n"
649 " transmit : %.3f\n"
650 " dest : %.3f\n"
651 " offset : %+.3f sec\n"
652 " delay : %+.3f sec\n"
653 " packet count : %"PRIu64"\n"
654 " jitter : %.3f%s\n"
655 " poll interval: " USEC_FMT "\n",
656 NTP_FIELD_LEAP(ntpmsg.field),
657 NTP_FIELD_VERSION(ntpmsg.field),
658 NTP_FIELD_MODE(ntpmsg.field),
659 ntpmsg.stratum,
660 exp2(ntpmsg.precision), ntpmsg.precision,
3af0442c 661 root_distance,
84e51726
LP		 662 ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
663 origin - OFFSET_1900_1970,
664 receive - OFFSET_1900_1970,
665 trans - OFFSET_1900_1970,
666 dest - OFFSET_1900_1970,
667 offset, delay,
668 m->packet_count,
669 m->samples_jitter, spike ? " spike" : "",
670 m->poll_interval_usec / USEC_PER_SEC);
671
672 if (!spike) {
673 m->sync = true;
674 r = manager_adjust_clock(m, offset, leap_sec);
675 if (r < 0)
56f64d95 676 log_error_errno(errno, "Failed to call clock_adjtime(): %m");
84e51726
LP		 677 }
678
679 log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
680 m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
681 spike ? " (ignored)" : "");
682
683 r = manager_arm_timer(m, m->poll_interval_usec);
f647962d
MS		 684 if (r < 0)
685 return log_error_errno(r, "Failed to rearm timer: %m");
84e51726
LP		 686
687 return 0;
688}
689
690static int manager_listen_setup(Manager *m) {
691 union sockaddr_union addr = {};
692 static const int tos = IPTOS_LOWDELAY;
693 static const int on = 1;
694 int r;
695
696 assert(m);
697
f89c4e15
LP		 698 if (m->server_socket >= 0)
699 return 0;
700
84e51726
LP		 701 assert(!m->event_receive);
702 assert(m->current_server_address);
703
704 addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
705
706 m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
707 if (m->server_socket < 0)
708 return -errno;
709
710 r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
711 if (r < 0)
712 return -errno;
713
487a3682 714 r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
84e51726
LP		 715 if (r < 0)
716 return -errno;
717
69f00817 718 (void) setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
84e51726
LP		 719
720 return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
721}
722
f89c4e15
LP		 723static void manager_listen_stop(Manager *m) {
724 assert(m);
725
726 m->event_receive = sd_event_source_unref(m->event_receive);
727 m->server_socket = safe_close(m->server_socket);
728}
729
84e51726
LP		 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
f89c4e15 959 manager_listen_stop(m);
84e51726
LP		 960
961 m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
962 m->clock_watch_fd = safe_close(m->clock_watch_fd);
963
964 m->event_timeout = sd_event_source_unref(m->event_timeout);
965
966 sd_notifyf(false, "STATUS=Idle.");
967}
968
874ff7bf
LP		 969void manager_flush_server_names(Manager *m, ServerType t) {
970 assert(m);
971
972 if (t == SERVER_SYSTEM)
973 while (m->system_servers)
974 server_name_free(m->system_servers);
975
976 if (t == SERVER_LINK)
977 while (m->link_servers)
978 server_name_free(m->link_servers);
979
980 if (t == SERVER_FALLBACK)
981 while (m->fallback_servers)
982 server_name_free(m->fallback_servers);
983}
84e51726
LP		 984
985void manager_free(Manager *m) {
986 if (!m)
987 return;
988
989 manager_disconnect(m);
874ff7bf
LP		 990 manager_flush_server_names(m, SERVER_SYSTEM);
991 manager_flush_server_names(m, SERVER_LINK);
992 manager_flush_server_names(m, SERVER_FALLBACK);
84e51726
LP		 993
994 sd_event_source_unref(m->event_retry);
995
996 sd_event_source_unref(m->network_event_source);
997 sd_network_monitor_unref(m->network_monitor);
998
999 sd_resolve_unref(m->resolve);
1000 sd_event_unref(m->event);
1001
1002 free(m);
1003}
1004
874ff7bf
LP		 1005static int manager_network_read_link_servers(Manager *m) {
1006 _cleanup_strv_free_ char **ntp = NULL;
1007 ServerName *n, *nx;
1008 char **i;
1009 int r;
1010
84e51726
LP		 1011 assert(m);
1012
874ff7bf
LP		 1013 r = sd_network_get_ntp(&ntp);
1014 if (r < 0)
1015 goto clear;
1016
1017 LIST_FOREACH(names, n, m->link_servers)
1018 n->marked = true;
1019
1020 STRV_FOREACH(i, ntp) {
1021 bool found = false;
1022
1023 LIST_FOREACH(names, n, m->link_servers)
1024 if (streq(n->string, *i)) {
1025 n->marked = false;
1026 found = true;
1027 break;
1028 }
1029
1030 if (!found) {
1031 r = server_name_new(m, NULL, SERVER_LINK, *i);
1032 if (r < 0)
1033 goto clear;
1034 }
1035 }
1036
1037 LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1038 if (n->marked)
1039 server_name_free(n);
1040
1041 return 0;
1042
1043clear:
1044 manager_flush_server_names(m, SERVER_LINK);
1045 return r;
84e51726
LP		 1046}
1047
1048static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1049 Manager *m = userdata;
1050 bool connected, online;
1051 int r;
1052
1053 assert(m);
1054
1055 sd_network_monitor_flush(m->network_monitor);
1056
874ff7bf
LP		 1057 manager_network_read_link_servers(m);
1058
84e51726
LP		 1059 /* check if the machine is online */
1060 online = network_is_online();
1061
1062 /* check if the client is currently connected */
63463bf0 1063 connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
84e51726
LP		 1064
1065 if (connected && !online) {
1066 log_info("No network connectivity, watching for changes.");
1067 manager_disconnect(m);
1068
1069 } else if (!connected && online) {
1070 log_info("Network configuration changed, trying to establish connection.");
1071
1072 if (m->current_server_address)
1073 r = manager_begin(m);
1074 else
1075 r = manager_connect(m);
1076 if (r < 0)
1077 return r;
1078 }
1079
1080 return 0;
1081}
1082
1083static int manager_network_monitor_listen(Manager *m) {
1084 int r, fd, events;
1085
1086 assert(m);
1087
1088 r = sd_network_monitor_new(&m->network_monitor, NULL);
1089 if (r < 0)
1090 return r;
1091
1092 fd = sd_network_monitor_get_fd(m->network_monitor);
1093 if (fd < 0)
1094 return fd;
1095
1096 events = sd_network_monitor_get_events(m->network_monitor);
1097 if (events < 0)
1098 return events;
1099
1100 r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1101 if (r < 0)
1102 return r;
1103
1104 return 0;
1105}
1106
1107int manager_new(Manager **ret) {
1108 _cleanup_(manager_freep) Manager *m = NULL;
1109 int r;
1110
1111 assert(ret);
1112
1113 m = new0(Manager, 1);
1114 if (!m)
1115 return -ENOMEM;
1116
1117 m->server_socket = m->clock_watch_fd = -1;
1118
1119 RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1120
874ff7bf 1121 r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
84e51726
LP		 1122 if (r < 0)
1123 return r;
1124
1125 r = sd_event_default(&m->event);
1126 if (r < 0)
1127 return r;
1128
1129 sd_event_add_signal(m->event, NULL, SIGTERM, NULL, NULL);
1130 sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1131
1132 sd_event_set_watchdog(m->event, true);
1133
1134 r = sd_resolve_default(&m->resolve);
1135 if (r < 0)
1136 return r;
1137
1138 r = sd_resolve_attach_event(m->resolve, m->event, 0);
1139 if (r < 0)
1140 return r;
1141
1142 r = manager_network_monitor_listen(m);
1143 if (r < 0)
1144 return r;
1145
c572db3c 1146 manager_network_read_link_servers(m);
874ff7bf 1147
84e51726
LP		 1148 *ret = m;
1149 m = NULL;
1150
1151 return 0;
1152}
Unnamed repository; edit this file 'description' to name the repository.