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