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