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