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