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