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         if (m->poll_interval_usec == 0)
 725                 m->poll_interval_usec = NTP_POLL_INTERVAL_MIN_SEC * USEC_PER_SEC;
 726
 727         server_address_pretty(m->current_server_address, &pretty);
 728         log_info("Using NTP server %s (%s).", strna(pretty), m->current_server_name->string);
 729         sd_notifyf(false, "STATUS=Using Time Server %s (%s).", strna(pretty), m->current_server_name->string);
 730
 731         r = manager_listen_setup(m);
 732         if (r < 0) {
 733                 log_warning("Failed to setup connection socket: %s", strerror(-r));
 734                 return r;
 735         }
 736
 737         r = manager_clock_watch_setup(m);
 738         if (r < 0)
 739                 return r;
 740
 741         return manager_send_request(m);
 742 }
 743
 744 void manager_set_server_name(Manager *m, ServerName *n) {
 745         assert(m);
 746
 747         if (m->current_server_name == n)
 748                 return;
 749
 750         m->current_server_name = n;
 751         m->current_server_address = NULL;
 752
 753         manager_disconnect(m);
 754
 755         if (n)
 756                 log_debug("Selected server %s.", n->string);
 757 }
 758
 759 void manager_set_server_address(Manager *m, ServerAddress *a) {
 760         assert(m);
 761
 762         if (m->current_server_address == a)
 763                 return;
 764
 765         m->current_server_address = a;
 766         /* If a is NULL, we are just clearing the address, without
 767          * changing the name. Keep the existing name in that case. */
 768         if (a)
 769                 m->current_server_name = a->name;
 770
 771         manager_disconnect(m);
 772
 773         if (a) {
 774                 _cleanup_free_ char *pretty = NULL;
 775                 server_address_pretty(a, &pretty);
 776                 log_debug("Selected address %s of server %s.", strna(pretty), a->name->string);
 777         }
 778 }
 779
 780 static int manager_resolve_handler(sd_resolve_query *q, int ret, const struct addrinfo *ai, void *userdata) {
 781         Manager *m = userdata;
 782         int r;
 783
 784         assert(q);
 785         assert(m);
 786         assert(m->current_server_name);
 787
 788         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 789
 790         if (ret != 0) {
 791                 log_debug("Failed to resolve %s: %s", m->current_server_name->string, gai_strerror(ret));
 792
 793                 /* Try next host */
 794                 return manager_connect(m);
 795         }
 796
 797         for (; ai; ai = ai->ai_next) {
 798                 _cleanup_free_ char *pretty = NULL;
 799                 ServerAddress *a;
 800
 801                 assert(ai->ai_addr);
 802                 assert(ai->ai_addrlen >= offsetof(struct sockaddr, sa_data));
 803
 804                 if (!IN_SET(ai->ai_addr->sa_family, AF_INET, AF_INET6)) {
 805                         log_warning("Unsuitable address protocol for %s", m->current_server_name->string);
 806                         continue;
 807                 }
 808
 809                 r = server_address_new(m->current_server_name, &a, (const union sockaddr_union*) ai->ai_addr, ai->ai_addrlen);
 810                 if (r < 0) {
 811                         log_error("Failed to add server address: %s", strerror(-r));
 812                         return r;
 813                 }
 814
 815                 server_address_pretty(a, &pretty);
 816                 log_debug("Resolved address %s for %s.", pretty, m->current_server_name->string);
 817         }
 818
 819         if (!m->current_server_name->addresses) {
 820                 log_error("Failed to find suitable address for host %s.", m->current_server_name->string);
 821
 822                 /* Try next host */
 823                 return manager_connect(m);
 824         }
 825
 826         manager_set_server_address(m, m->current_server_name->addresses);
 827
 828         return manager_begin(m);
 829 }
 830
 831 static int manager_retry_connect(sd_event_source *source, usec_t usec, void *userdata) {
 832         Manager *m = userdata;
 833
 834         assert(m);
 835
 836         return manager_connect(m);
 837 }
 838
 839 int manager_connect(Manager *m) {
 840         int r;
 841
 842         assert(m);
 843
 844         manager_disconnect(m);
 845
 846         m->event_retry = sd_event_source_unref(m->event_retry);
 847         if (!ratelimit_test(&m->ratelimit)) {
 848                 log_debug("Slowing down attempts to contact servers.");
 849
 850                 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);
 851                 if (r < 0) {
 852                         log_error("Failed to create retry timer: %s", strerror(-r));
 853                         return r;
 854                 }
 855
 856                 return 0;
 857         }
 858
 859         /* If we already are operating on some address, switch to the
 860          * next one. */
 861         if (m->current_server_address && m->current_server_address->addresses_next)
 862                 manager_set_server_address(m, m->current_server_address->addresses_next);
 863         else {
 864                 struct addrinfo hints = {
 865                         .ai_flags = AI_NUMERICSERV|AI_ADDRCONFIG,
 866                         .ai_socktype = SOCK_DGRAM,
 867                 };
 868
 869                 /* Hmm, we are through all addresses, let's look for the next host instead */
 870                 if (m->current_server_name && m->current_server_name->names_next)
 871                         manager_set_server_name(m, m->current_server_name->names_next);
 872                 else {
 873                         ServerName *f;
 874                         bool restart = true;
 875
 876                         /* Our current server name list is exhausted,
 877                          * let's find the next one to iterate. First
 878                          * we try the system list, then the link list.
 879                          * After having processed the link list we
 880                          * jump back to the system list. However, if
 881                          * both lists are empty, we change to the
 882                          * fallback list. */
 883                         if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
 884                                 f = m->system_servers;
 885                                 if (!f)
 886                                         f = m->link_servers;
 887                         } else {
 888                                 f = m->link_servers;
 889                                 if (!f)
 890                                         f = m->system_servers;
 891                                 else
 892                                         restart = false;
 893                         }
 894
 895                         if (!f)
 896                                 f = m->fallback_servers;
 897
 898                         if (!f) {
 899                                 manager_set_server_name(m, NULL);
 900                                 log_debug("No server found.");
 901                                 return 0;
 902                         }
 903
 904                         if (restart && !m->exhausted_servers && m->poll_interval_usec) {
 905                                 log_debug("Waiting after exhausting servers.");
 906                                 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);
 907                                 if (r < 0) {
 908                                         log_error("Failed to create retry timer: %s", strerror(-r));
 909                                         return r;
 910                                 }
 911
 912                                 m->exhausted_servers = true;
 913
 914                                 /* Increase the polling interval */
 915                                 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 916                                         m->poll_interval_usec *= 2;
 917
 918                                 return 0;
 919                         }
 920
 921                         m->exhausted_servers = false;
 922
 923                         manager_set_server_name(m, f);
 924                 }
 925
 926                 /* Tell the resolver to reread /etc/resolv.conf, in
 927                  * case it changed. */
 928                 res_init();
 929
 930                 /* Flush out any previously resolved addresses */
 931                 server_name_flush_addresses(m->current_server_name);
 932
 933                 log_debug("Resolving %s...", m->current_server_name->string);
 934
 935                 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
 936                 if (r < 0) {
 937                         log_error("Failed to create resolver: %s", strerror(-r));
 938                         return r;
 939                 }
 940
 941                 return 1;
 942         }
 943
 944         r = manager_begin(m);
 945         if (r < 0)
 946                 return r;
 947
 948         return 1;
 949 }
 950
 951 void manager_disconnect(Manager *m) {
 952         assert(m);
 953
 954         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 955
 956         m->event_timer = sd_event_source_unref(m->event_timer);
 957
 958         m->event_receive = sd_event_source_unref(m->event_receive);
 959         m->server_socket = safe_close(m->server_socket);
 960
 961         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
 962         m->clock_watch_fd = safe_close(m->clock_watch_fd);
 963
 964         m->event_timeout = sd_event_source_unref(m->event_timeout);
 965
 966         sd_notifyf(false, "STATUS=Idle.");
 967 }
 968
 969 void manager_flush_server_names(Manager  *m, ServerType t) {
 970         assert(m);
 971
 972         if (t == SERVER_SYSTEM)
 973                 while (m->system_servers)
 974                         server_name_free(m->system_servers);
 975
 976         if (t == SERVER_LINK)
 977                 while (m->link_servers)
 978                         server_name_free(m->link_servers);
 979
 980         if (t == SERVER_FALLBACK)
 981                 while (m->fallback_servers)
 982                         server_name_free(m->fallback_servers);
 983 }
 984
 985 void manager_free(Manager *m) {
 986         if (!m)
 987                 return;
 988
 989         manager_disconnect(m);
 990         manager_flush_server_names(m, SERVER_SYSTEM);
 991         manager_flush_server_names(m, SERVER_LINK);
 992         manager_flush_server_names(m, SERVER_FALLBACK);
 993
 994         sd_event_source_unref(m->event_retry);
 995
 996         sd_event_source_unref(m->network_event_source);
 997         sd_network_monitor_unref(m->network_monitor);
 998
 999         sd_resolve_unref(m->resolve);
1000         sd_event_unref(m->event);
1001
1002         free(m);
1003 }
1004
1005 static int manager_network_read_link_servers(Manager *m) {
1006         _cleanup_strv_free_ char **ntp = NULL;
1007         ServerName *n, *nx;
1008         char **i;
1009         int r;
1010
1011         assert(m);
1012
1013         r = sd_network_get_ntp(&ntp);
1014         if (r < 0)
1015                 goto clear;
1016
1017         LIST_FOREACH(names, n, m->link_servers)
1018                 n->marked = true;
1019
1020         STRV_FOREACH(i, ntp) {
1021                 bool found = false;
1022
1023                 LIST_FOREACH(names, n, m->link_servers)
1024                         if (streq(n->string, *i)) {
1025                                 n->marked = false;
1026                                 found = true;
1027                                 break;
1028                         }
1029
1030                 if (!found) {
1031                         r = server_name_new(m, NULL, SERVER_LINK, *i);
1032                         if (r < 0)
1033                                 goto clear;
1034                 }
1035         }
1036
1037         LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1038                 if (n->marked)
1039                         server_name_free(n);
1040
1041         return 0;
1042
1043 clear:
1044         manager_flush_server_names(m, SERVER_LINK);
1045         return r;
1046 }
1047
1048 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1049         Manager *m = userdata;
1050         bool connected, online;
1051         int r;
1052
1053         assert(m);
1054
1055         sd_network_monitor_flush(m->network_monitor);
1056
1057         manager_network_read_link_servers(m);
1058
1059         /* check if the machine is online */
1060         online = network_is_online();
1061
1062         /* check if the client is currently connected */
1063         connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1064
1065         if (connected && !online) {
1066                 log_info("No network connectivity, watching for changes.");
1067                 manager_disconnect(m);
1068
1069         } else if (!connected && online) {
1070                 log_info("Network configuration changed, trying to establish connection.");
1071
1072                 if (m->current_server_address)
1073                         r = manager_begin(m);
1074                 else
1075                         r = manager_connect(m);
1076                 if (r < 0)
1077                         return r;
1078         }
1079
1080         return 0;
1081 }
1082
1083 static int manager_network_monitor_listen(Manager *m) {
1084         int r, fd, events;
1085
1086         assert(m);
1087
1088         r = sd_network_monitor_new(&m->network_monitor, NULL);
1089         if (r < 0)
1090                 return r;
1091
1092         fd = sd_network_monitor_get_fd(m->network_monitor);
1093         if (fd < 0)
1094                 return fd;
1095
1096         events = sd_network_monitor_get_events(m->network_monitor);
1097         if (events < 0)
1098                 return events;
1099
1100         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1101         if (r < 0)
1102                 return r;
1103
1104         return 0;
1105 }
1106
1107 int manager_new(Manager **ret) {
1108         _cleanup_(manager_freep) Manager *m = NULL;
1109         int r;
1110
1111         assert(ret);
1112
1113         m = new0(Manager, 1);
1114         if (!m)
1115                 return -ENOMEM;
1116
1117         m->server_socket = m->clock_watch_fd = -1;
1118
1119         RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1120
1121         r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1122         if (r < 0)
1123                 return r;
1124
1125         r = sd_event_default(&m->event);
1126         if (r < 0)
1127                 return r;
1128
1129         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
1130         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1131
1132         sd_event_set_watchdog(m->event, true);
1133
1134         r = sd_resolve_default(&m->resolve);
1135         if (r < 0)
1136                 return r;
1137
1138         r = sd_resolve_attach_event(m->resolve, m->event, 0);
1139         if (r < 0)
1140                 return r;
1141
1142         r = manager_network_monitor_listen(m);
1143         if (r < 0)
1144                 return r;
1145
1146         manager_network_read_link_servers(m);
1147
1148         *ret = m;
1149         m = NULL;
1150
1151         return 0;
1152 }