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