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