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