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 /* Maximum acceptable root distance in seconds. */
  93 #define NTP_MAX_ROOT_DISTANCE           5.0
  94
  95 /* Maximum number of missed replies before selecting another source. */
  96 #define NTP_MAX_MISSED_REPLIES          2
  97
  98 /*
  99  * "NTP timestamps are represented as a 64-bit unsigned fixed-point number,
 100  * in seconds relative to 0h on 1 January 1900."
 101  */
 102 #define OFFSET_1900_1970        2208988800UL
 103
 104 #define RETRY_USEC (30*USEC_PER_SEC)
 105 #define RATELIMIT_INTERVAL_USEC (10*USEC_PER_SEC)
 106 #define RATELIMIT_BURST 10
 107
 108 #define TIMEOUT_USEC (10*USEC_PER_SEC)
 109
 110 struct ntp_ts {
 111         be32_t sec;
 112         be32_t frac;
 113 } _packed_;
 114
 115 struct ntp_ts_short {
 116         be16_t sec;
 117         be16_t frac;
 118 } _packed_;
 119
 120 struct ntp_msg {
 121         uint8_t field;
 122         uint8_t stratum;
 123         int8_t poll;
 124         int8_t precision;
 125         struct ntp_ts_short root_delay;
 126         struct ntp_ts_short root_dispersion;
 127         char refid[4];
 128         struct ntp_ts reference_time;
 129         struct ntp_ts origin_time;
 130         struct ntp_ts recv_time;
 131         struct ntp_ts trans_time;
 132 } _packed_;
 133
 134 static int manager_arm_timer(Manager *m, usec_t next);
 135 static int manager_clock_watch_setup(Manager *m);
 136
 137 static double ntp_ts_short_to_d(const struct ntp_ts_short *ts) {
 138         return be16toh(ts->sec) + (be16toh(ts->frac) / 65536.0);
 139 }
 140
 141 static double ntp_ts_to_d(const struct ntp_ts *ts) {
 142         return be32toh(ts->sec) + ((double)be32toh(ts->frac) / UINT_MAX);
 143 }
 144
 145 static double ts_to_d(const struct timespec *ts) {
 146         return ts->tv_sec + (1.0e-9 * ts->tv_nsec);
 147 }
 148
 149 static double square(double d) {
 150         return d * d;
 151 }
 152
 153 static int manager_timeout(sd_event_source *source, usec_t usec, void *userdata) {
 154         _cleanup_free_ char *pretty = NULL;
 155         Manager *m = userdata;
 156
 157         assert(m);
 158         assert(m->current_server_name);
 159         assert(m->current_server_address);
 160
 161         server_address_pretty(m->current_server_address, &pretty);
 162         log_info("Timed out waiting for reply from %s (%s).", strna(pretty), m->current_server_name->string);
 163
 164         return manager_connect(m);
 165 }
 166
 167 static int manager_send_request(Manager *m) {
 168         _cleanup_free_ char *pretty = NULL;
 169         struct ntp_msg ntpmsg = {
 170                 /*
 171                  * "The client initializes the NTP message header, sends the request
 172                  * to the server, and strips the time of day from the Transmit
 173                  * Timestamp field of the reply.  For this purpose, all the NTP
 174                  * header fields are set to 0, except the Mode, VN, and optional
 175                  * Transmit Timestamp fields."
 176                  */
 177                 .field = NTP_FIELD(0, 4, NTP_MODE_CLIENT),
 178         };
 179         ssize_t len;
 180         int r;
 181
 182         assert(m);
 183         assert(m->current_server_name);
 184         assert(m->current_server_address);
 185
 186         m->event_timeout = sd_event_source_unref(m->event_timeout);
 187
 188         /*
 189          * Set transmit timestamp, remember it; the server will send that back
 190          * as the origin timestamp and we have an indication that this is the
 191          * matching answer to our request.
 192          *
 193          * The actual value does not matter, We do not care about the correct
 194          * NTP UINT_MAX fraction; we just pass the plain nanosecond value.
 195          */
 196         assert_se(clock_gettime(clock_boottime_or_monotonic(), &m->trans_time_mon) >= 0);
 197         assert_se(clock_gettime(CLOCK_REALTIME, &m->trans_time) >= 0);
 198         ntpmsg.trans_time.sec = htobe32(m->trans_time.tv_sec + OFFSET_1900_1970);
 199         ntpmsg.trans_time.frac = htobe32(m->trans_time.tv_nsec);
 200
 201         server_address_pretty(m->current_server_address, &pretty);
 202
 203         len = sendto(m->server_socket, &ntpmsg, sizeof(ntpmsg), MSG_DONTWAIT, &m->current_server_address->sockaddr.sa, m->current_server_address->socklen);
 204         if (len == sizeof(ntpmsg)) {
 205                 m->pending = true;
 206                 log_debug("Sent NTP request to %s (%s).", strna(pretty), m->current_server_name->string);
 207         } else {
 208                 log_debug("Sending NTP request to %s (%s) failed: %m", strna(pretty), m->current_server_name->string);
 209                 return manager_connect(m);
 210         }
 211
 212         m->missed_replies++;
 213         if (m->missed_replies > NTP_MAX_MISSED_REPLIES) {
 214                 r = sd_event_add_time(
 215                                 m->event,
 216                                 &m->event_timeout,
 217                                 clock_boottime_or_monotonic(),
 218                                 now(clock_boottime_or_monotonic()) + TIMEOUT_USEC, 0,
 219                                 manager_timeout, m);
 220                 if (r < 0) {
 221                         log_error("Failed to arm timeout timer: %s", strerror(-r));
 222                         return r;
 223                 }
 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         double root_distance;
 504         bool spike;
 505         int leap_sec;
 506         int r;
 507
 508         assert(source);
 509         assert(m);
 510
 511         if (revents & (EPOLLHUP|EPOLLERR)) {
 512                 log_warning("Server connection returned error.");
 513                 return manager_connect(m);
 514         }
 515
 516         len = recvmsg(fd, &msghdr, MSG_DONTWAIT);
 517         if (len < 0) {
 518                 if (errno == EAGAIN)
 519                         return 0;
 520
 521                 log_warning("Error receiving message. Disconnecting.");
 522                 return manager_connect(m);
 523         }
 524
 525         if (iov.iov_len < sizeof(struct ntp_msg)) {
 526                 log_warning("Invalid response from server. Disconnecting.");
 527                 return manager_connect(m);
 528         }
 529
 530         if (!m->current_server_name ||
 531             !m->current_server_address ||
 532             !sockaddr_equal(&server_addr, &m->current_server_address->sockaddr)) {
 533                 log_debug("Response from unknown server.");
 534                 return 0;
 535         }
 536
 537         recv_time = NULL;
 538         for (cmsg = CMSG_FIRSTHDR(&msghdr); cmsg; cmsg = CMSG_NXTHDR(&msghdr, cmsg)) {
 539                 if (cmsg->cmsg_level != SOL_SOCKET)
 540                         continue;
 541
 542                 switch (cmsg->cmsg_type) {
 543                 case SCM_TIMESTAMPNS:
 544                         recv_time = (struct timespec *) CMSG_DATA(cmsg);
 545                         break;
 546                 }
 547         }
 548         if (!recv_time) {
 549                 log_error("Invalid packet timestamp.");
 550                 return -EINVAL;
 551         }
 552
 553         if (!m->pending) {
 554                 log_debug("Unexpected reply. Ignoring.");
 555                 return 0;
 556         }
 557
 558         m->missed_replies = 0;
 559
 560         /* check our "time cookie" (we just stored nanoseconds in the fraction field) */
 561         if (be32toh(ntpmsg.origin_time.sec) != m->trans_time.tv_sec + OFFSET_1900_1970 ||
 562             be32toh(ntpmsg.origin_time.frac) != m->trans_time.tv_nsec) {
 563                 log_debug("Invalid reply; not our transmit time. Ignoring.");
 564                 return 0;
 565         }
 566
 567         m->event_timeout = sd_event_source_unref(m->event_timeout);
 568
 569         if (be32toh(ntpmsg.recv_time.sec) < TIME_EPOCH + OFFSET_1900_1970 ||
 570             be32toh(ntpmsg.trans_time.sec) < TIME_EPOCH + OFFSET_1900_1970) {
 571                 log_debug("Invalid reply, returned times before epoch. Ignoring.");
 572                 return manager_connect(m);
 573         }
 574
 575         if (NTP_FIELD_LEAP(ntpmsg.field) == NTP_LEAP_NOTINSYNC ||
 576             ntpmsg.stratum == 0 || ntpmsg.stratum >= 16) {
 577                 log_debug("Server is not synchronized. Disconnecting.");
 578                 return manager_connect(m);
 579         }
 580
 581         if (!IN_SET(NTP_FIELD_VERSION(ntpmsg.field), 3, 4)) {
 582                 log_debug("Response NTPv%d. Disconnecting.", NTP_FIELD_VERSION(ntpmsg.field));
 583                 return manager_connect(m);
 584         }
 585
 586         if (NTP_FIELD_MODE(ntpmsg.field) != NTP_MODE_SERVER) {
 587                 log_debug("Unsupported mode %d. Disconnecting.", NTP_FIELD_MODE(ntpmsg.field));
 588                 return manager_connect(m);
 589         }
 590
 591         root_distance = ntp_ts_short_to_d(&ntpmsg.root_delay) / 2 + ntp_ts_short_to_d(&ntpmsg.root_dispersion);
 592         if (root_distance > NTP_MAX_ROOT_DISTANCE) {
 593                 log_debug("Server has too large root distance. Disconnecting.");
 594                 return manager_connect(m);
 595         }
 596
 597         /* valid packet */
 598         m->pending = false;
 599
 600         /* announce leap seconds */
 601         if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_PLUSSEC)
 602                 leap_sec = 1;
 603         else if (NTP_FIELD_LEAP(ntpmsg.field) & NTP_LEAP_MINUSSEC)
 604                 leap_sec = -1;
 605         else
 606                 leap_sec = 0;
 607
 608         /*
 609          * "Timestamp Name          ID   When Generated
 610          *  ------------------------------------------------------------
 611          *  Originate Timestamp     T1   time request sent by client
 612          *  Receive Timestamp       T2   time request received by server
 613          *  Transmit Timestamp      T3   time reply sent by server
 614          *  Destination Timestamp   T4   time reply received by client
 615          *
 616          *  The round-trip delay, d, and system clock offset, t, are defined as:
 617          *  d = (T4 - T1) - (T3 - T2)     t = ((T2 - T1) + (T3 - T4)) / 2"
 618          */
 619         origin = ts_to_d(&m->trans_time) + OFFSET_1900_1970;
 620         receive = ntp_ts_to_d(&ntpmsg.recv_time);
 621         trans = ntp_ts_to_d(&ntpmsg.trans_time);
 622         dest = ts_to_d(recv_time) + OFFSET_1900_1970;
 623
 624         offset = ((receive - origin) + (trans - dest)) / 2;
 625         delay = (dest - origin) - (trans - receive);
 626
 627         spike = manager_sample_spike_detection(m, offset, delay);
 628
 629         manager_adjust_poll(m, offset, spike);
 630
 631         log_debug("NTP response:\n"
 632                   "  leap         : %u\n"
 633                   "  version      : %u\n"
 634                   "  mode         : %u\n"
 635                   "  stratum      : %u\n"
 636                   "  precision    : %.6f sec (%d)\n"
 637                   "  root distance: %.6f sec\n"
 638                   "  reference    : %.4s\n"
 639                   "  origin       : %.3f\n"
 640                   "  receive      : %.3f\n"
 641                   "  transmit     : %.3f\n"
 642                   "  dest         : %.3f\n"
 643                   "  offset       : %+.3f sec\n"
 644                   "  delay        : %+.3f sec\n"
 645                   "  packet count : %"PRIu64"\n"
 646                   "  jitter       : %.3f%s\n"
 647                   "  poll interval: " USEC_FMT "\n",
 648                   NTP_FIELD_LEAP(ntpmsg.field),
 649                   NTP_FIELD_VERSION(ntpmsg.field),
 650                   NTP_FIELD_MODE(ntpmsg.field),
 651                   ntpmsg.stratum,
 652                   exp2(ntpmsg.precision), ntpmsg.precision,
 653                   root_distance,
 654                   ntpmsg.stratum == 1 ? ntpmsg.refid : "n/a",
 655                   origin - OFFSET_1900_1970,
 656                   receive - OFFSET_1900_1970,
 657                   trans - OFFSET_1900_1970,
 658                   dest - OFFSET_1900_1970,
 659                   offset, delay,
 660                   m->packet_count,
 661                   m->samples_jitter, spike ? " spike" : "",
 662                   m->poll_interval_usec / USEC_PER_SEC);
 663
 664         if (!spike) {
 665                 m->sync = true;
 666                 r = manager_adjust_clock(m, offset, leap_sec);
 667                 if (r < 0)
 668                         log_error("Failed to call clock_adjtime(): %m");
 669         }
 670
 671         log_info("interval/delta/delay/jitter/drift " USEC_FMT "s/%+.3fs/%.3fs/%.3fs/%+ippm%s",
 672                  m->poll_interval_usec / USEC_PER_SEC, offset, delay, m->samples_jitter, m->drift_ppm,
 673                  spike ? " (ignored)" : "");
 674
 675         r = manager_arm_timer(m, m->poll_interval_usec);
 676         if (r < 0) {
 677                 log_error("Failed to rearm timer: %s", strerror(-r));
 678                 return r;
 679         }
 680
 681         return 0;
 682 }
 683
 684 static int manager_listen_setup(Manager *m) {
 685         union sockaddr_union addr = {};
 686         static const int tos = IPTOS_LOWDELAY;
 687         static const int on = 1;
 688         int r;
 689
 690         assert(m);
 691
 692         assert(m->server_socket < 0);
 693         assert(!m->event_receive);
 694         assert(m->current_server_address);
 695
 696         addr.sa.sa_family = m->current_server_address->sockaddr.sa.sa_family;
 697
 698         m->server_socket = socket(addr.sa.sa_family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 699         if (m->server_socket < 0)
 700                 return -errno;
 701
 702         r = bind(m->server_socket, &addr.sa, m->current_server_address->socklen);
 703         if (r < 0)
 704                 return -errno;
 705
 706         r = setsockopt(m->server_socket, SOL_SOCKET, SO_TIMESTAMPNS, &on, sizeof(on));
 707         if (r < 0)
 708                 return -errno;
 709
 710         setsockopt(m->server_socket, IPPROTO_IP, IP_TOS, &tos, sizeof(tos));
 711
 712         return sd_event_add_io(m->event, &m->event_receive, m->server_socket, EPOLLIN, manager_receive_response, m);
 713 }
 714
 715 static int manager_begin(Manager *m) {
 716         _cleanup_free_ char *pretty = NULL;
 717         int r;
 718
 719         assert(m);
 720         assert_return(m->current_server_name, -EHOSTUNREACH);
 721         assert_return(m->current_server_address, -EHOSTUNREACH);
 722
 723         m->missed_replies = NTP_MAX_MISSED_REPLIES;
 724         m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 725
 726         server_address_pretty(m->current_server_address, &pretty);
 727         log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
 728         sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
 729
 730         r = manager_listen_setup(m);
 731         if (r < 0) {
 732                 log_warning("Failed to setup connection socket: %s", strerror(-r));
 733                 return r;
 734         }
 735
 736         r = manager_clock_watch_setup(m);
 737         if (r < 0)
 738                 return r;
 739
 740         return manager_send_request(m);
 741 }
 742
 743 void manager_set_server_name(Manager *m, ServerName *n) {
 744         assert(m);
 745
 746         if (m->current_server_name == n)
 747                 return;
 748
 749         m->current_server_name = n;
 750         m->current_server_address = NULL;
 751
 752         manager_disconnect(m);
 753
 754         if (n)
 755                 log_debug("Selected server %s.", n->string);
 756 }
 757
 758 void manager_set_server_address(Manager *m, ServerAddress *a) {
 759         assert(m);
 760
 761         if (m->current_server_address == a)
 762                 return;
 763
 764         m->current_server_address = a;
 765         /* If a is NULL, we are just clearing the address, without
 766          * changing the name. Keep the existing name in that case. */
 767         if (a)
 768                 m->current_server_name = a->name;
 769
 770         manager_disconnect(m);
 771
 772         if (a) {
 773                 _cleanup_free_ char *pretty = NULL;
 774                 server_address_pretty(a, &pretty);
 775                 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
 776         }
 777 }
 778
 779 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
 780         Manager *m = userdata;
 781         int r;
 782
 783         assert(q);
 784         assert(m);
 785         assert(m->current_server_name);
 786
 787         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 788
 789         if (ret != 0) {
 790                 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
 791
 792                 /* Try next host */
 793                 return manager_connect(m);
 794         }
 795
 796         for (; ai; ai = ai->ai_next) {
 797                 _cleanup_free_ char *pretty = NULL;
 798                 ServerAddress *a;
 799
 800                 assert(ai->ai_addr);
 801                 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
 802
 803                 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
 804                         log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
 805                         continue;
 806                 }
 807
 808                 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
 809                 if (r < 0) {
 810                         log_error("Failed to add server address: %s", strerror(-r));
 811                         return r;
 812                 }
 813
 814                 server_address_pretty(a, &pretty);
 815                 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
 816         }
 817
 818         if (!m->current_server_name->addresses) {
 819                 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
 820
 821                 /* Try next host */
 822                 return manager_connect(m);
 823         }
 824
 825         manager_set_server_address(m, m->current_server_name->addresses);
 826
 827         return manager_begin(m);
 828 }
 829
 830 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
 831         Manager *m = userdata;
 832
 833         assert(m);
 834
 835         return manager_connect(m);
 836 }
 837
 838 int manager_connect(Manager *m) {
 839         int r;
 840
 841         assert(m);
 842
 843         manager_disconnect(m);
 844
 845         m->event_retry = sd_event_source_unref(m->event_retry);
 846         if (!ratelimit_test(&m->ratelimit)) {
 847                 log_debug("Slowing down attempts to contact servers.");
 848
 849                 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);
 850                 if (r < 0) {
 851                         log_error("Failed to create retry timer: %s", strerror(-r));
 852                         return r;
 853                 }
 854
 855                 return 0;
 856         }
 857
 858         /* If we already are operating on some address, switch to the
 859          * next one. */
 860         if (m->current_server_address && m->current_server_address->addresses_next)
 861                 manager_set_server_address(m, m->current_server_address->addresses_next);
 862         else {
 863                 struct addrinfo hints = {
 864                         .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
 865                         .ai_socktype = SOCK_DGRAM,
 866                 };
 867
 868                 /* Hmm, we are through all addresses, let's look for the next host instead */
 869                 if (m->current_server_name && m->current_server_name->names_next)
 870                         manager_set_server_name(m, m->current_server_name->names_next);
 871                 else {
 872                         ServerName *f;
 873                         bool restart = true;
 874
 875                         /* Our current server name list is exhausted,
 876                          * let's find the next one to iterate. First
 877                          * we try the system list, then the link list.
 878                          * After having processed the link list we
 879                          * jump back to the system list. However, if
 880                          * both lists are empty, we change to the
 881                          * fallback list. */
 882                         if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
 883                                 f = m->system_servers;
 884                                 if (!f)
 885                                         f = m->link_servers;
 886                         } else {
 887                                 f = m->link_servers;
 888                                 if (!f)
 889                                         f = m->system_servers;
 890                                 else
 891                                         restart = false;
 892                         }
 893
 894                         if (!f)
 895                                 f = m->fallback_servers;
 896
 897                         if (!f) {
 898                                 manager_set_server_name(m, NULL);
 899                                 log_debug("No server found.");
 900                                 return 0;
 901                         }
 902
 903                         if (restart && !m->exhausted_servers && m->poll_interval_usec) {
 904                                 log_debug("Waiting after exhausting servers.");
 905                                 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);
 906                                 if (r < 0) {
 907                                         log_error("Failed to create retry timer: %s", strerror(-r));
 908                                         return r;
 909                                 }
 910
 911                                 m->exhausted_servers = true;
 912
 913                                 /* Increase the polling interval */
 914                                 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 915                                         m->poll_interval_usec *= 2;
 916
 917                                 return 0;
 918                         }
 919
 920                         m->exhausted_servers = false;
 921
 922                         manager_set_server_name(m, f);
 923                 }
 924
 925                 /* Tell the resolver to reread /etc/resolv.conf, in
 926                  * case it changed. */
 927                 res_init();
 928
 929                 /* Flush out any previously resolved addresses */
 930                 server_name_flush_addresses(m->current_server_name);
 931
 932                 log_debug("Resolving %s...", m->current_server_name->string);
 933
 934                 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
 935                 if (r < 0) {
 936                         log_error("Failed to create resolver: %s", strerror(-r));
 937                         return r;
 938                 }
 939
 940                 return 1;
 941         }
 942
 943         r = manager_begin(m);
 944         if (r < 0)
 945                 return r;
 946
 947         return 1;
 948 }
 949
 950 void manager_disconnect(Manager *m) {
 951         assert(m);
 952
 953         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 954
 955         m->event_timer = sd_event_source_unref(m->event_timer);
 956
 957         m->event_receive = sd_event_source_unref(m->event_receive);
 958         m->server_socket = safe_close(m->server_socket);
 959
 960         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
 961         m->clock_watch_fd = safe_close(m->clock_watch_fd);
 962
 963         m->event_timeout = sd_event_source_unref(m->event_timeout);
 964
 965         sd_notifyf(false, "STATUS=Idle.");
 966 }
 967
 968 void manager_flush_server_names(Manager  *m, ServerType t) {
 969         assert(m);
 970
 971         if (t == SERVER_SYSTEM)
 972                 while (m->system_servers)
 973                         server_name_free(m->system_servers);
 974
 975         if (t == SERVER_LINK)
 976                 while (m->link_servers)
 977                         server_name_free(m->link_servers);
 978
 979         if (t == SERVER_FALLBACK)
 980                 while (m->fallback_servers)
 981                         server_name_free(m->fallback_servers);
 982 }
 983
 984 void manager_free(Manager *m) {
 985         if (!m)
 986                 return;
 987
 988         manager_disconnect(m);
 989         manager_flush_server_names(m, SERVER_SYSTEM);
 990         manager_flush_server_names(m, SERVER_LINK);
 991         manager_flush_server_names(m, SERVER_FALLBACK);
 992
 993         sd_event_source_unref(m->event_retry);
 994
 995         sd_event_source_unref(m->network_event_source);
 996         sd_network_monitor_unref(m->network_monitor);
 997
 998         sd_resolve_unref(m->resolve);
 999         sd_event_unref(m->event);
1000
1001         free(m);
1002 }
1003
1004 static int manager_network_read_link_servers(Manager *m) {
1005         _cleanup_strv_free_ char **ntp = NULL;
1006         ServerName *n, *nx;
1007         char **i;
1008         int r;
1009
1010         assert(m);
1011
1012         r = sd_network_get_ntp(&ntp);
1013         if (r < 0)
1014                 goto clear;
1015
1016         LIST_FOREACH(names, n, m->link_servers)
1017                 n->marked = true;
1018
1019         STRV_FOREACH(i, ntp) {
1020                 bool found = false;
1021
1022                 LIST_FOREACH(names, n, m->link_servers)
1023                         if (streq(n->string, *i)) {
1024                                 n->marked = false;
1025                                 found = true;
1026                                 break;
1027                         }
1028
1029                 if (!found) {
1030                         r = server_name_new(m, NULL, SERVER_LINK, *i);
1031                         if (r < 0)
1032                                 goto clear;
1033                 }
1034         }
1035
1036         LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1037                 if (n->marked)
1038                         server_name_free(n);
1039
1040         return 0;
1041
1042 clear:
1043         manager_flush_server_names(m, SERVER_LINK);
1044         return r;
1045 }
1046
1047 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1048         Manager *m = userdata;
1049         bool connected, online;
1050         int r;
1051
1052         assert(m);
1053
1054         sd_network_monitor_flush(m->network_monitor);
1055
1056         manager_network_read_link_servers(m);
1057
1058         /* check if the machine is online */
1059         online = network_is_online();
1060
1061         /* check if the client is currently connected */
1062         connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1063
1064         if (connected && !online) {
1065                 log_info("No network connectivity, watching for changes.");
1066                 manager_disconnect(m);
1067
1068         } else if (!connected && online) {
1069                 log_info("Network configuration changed, trying to establish connection.");
1070
1071                 if (m->current_server_address)
1072                         r = manager_begin(m);
1073                 else
1074                         r = manager_connect(m);
1075                 if (r < 0)
1076                         return r;
1077         }
1078
1079         return 0;
1080 }
1081
1082 static int manager_network_monitor_listen(Manager *m) {
1083         int r, fd, events;
1084
1085         assert(m);
1086
1087         r = sd_network_monitor_new(&m->network_monitor, NULL);
1088         if (r < 0)
1089                 return r;
1090
1091         fd = sd_network_monitor_get_fd(m->network_monitor);
1092         if (fd < 0)
1093                 return fd;
1094
1095         events = sd_network_monitor_get_events(m->network_monitor);
1096         if (events < 0)
1097                 return events;
1098
1099         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1100         if (r < 0)
1101                 return r;
1102
1103         return 0;
1104 }
1105
1106 int manager_new(Manager **ret) {
1107         _cleanup_(manager_freep) Manager *m = NULL;
1108         int r;
1109
1110         assert(ret);
1111
1112         m = new0(Manager, 1);
1113         if (!m)
1114                 return -ENOMEM;
1115
1116         m->server_socket = m->clock_watch_fd = -1;
1117
1118         RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1119
1120         r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1121         if (r < 0)
1122                 return r;
1123
1124         r = sd_event_default(&m->event);
1125         if (r < 0)
1126                 return r;
1127
1128         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
1129         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1130
1131         sd_event_set_watchdog(m->event, true);
1132
1133         r = sd_resolve_default(&m->resolve);
1134         if (r < 0)
1135                 return r;
1136
1137         r = sd_resolve_attach_event(m->resolve, m->event, 0);
1138         if (r < 0)
1139                 return r;
1140
1141         r = manager_network_monitor_listen(m);
1142         if (r < 0)
1143                 return r;
1144
1145         manager_network_read_link_servers(m);
1146
1147         *ret = m;
1148         m = NULL;
1149
1150         return 0;
1151 }