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