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                         bool restart = true;
 879
 880                         /* Our current server name list is exhausted,
 881                          * let's find the next one to iterate. First
 882                          * we try the system list, then the link list.
 883                          * After having processed the link list we
 884                          * jump back to the system list. However, if
 885                          * both lists are empty, we change to the
 886                          * fallback list. */
 887                         if (!m->current_server_name || m->current_server_name->type == SERVER_LINK) {
 888                                 f = m->system_servers;
 889                                 if (!f)
 890                                         f = m->link_servers;
 891                         } else {
 892                                 f = m->link_servers;
 893                                 if (!f)
 894                                         f = m->system_servers;
 895                                 else
 896                                         restart = false;
 897                         }
 898
 899                         if (!f)
 900                                 f = m->fallback_servers;
 901
 902                         if (!f) {
 903                                 manager_set_server_name(m, NULL);
 904                                 log_debug("No server found.");
 905                                 return 0;
 906                         }
 907
 908                         if (restart && !m->exhausted_servers && m->poll_interval_usec) {
 909                                 log_debug("Waiting after exhausting servers.");
 910                                 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);
 911                                 if (r < 0) {
 912                                         log_error("Failed to create retry timer: %s", strerror(-r));
 913                                         return r;
 914                                 }
 915
 916                                 m->exhausted_servers = true;
 917
 918                                 /* Increase the polling interval */
 919                                 if (m->poll_interval_usec < NTP_POLL_INTERVAL_MAX_SEC * USEC_PER_SEC)
 920                                         m->poll_interval_usec *= 2;
 921
 922                                 return 0;
 923                         }
 924
 925                         m->exhausted_servers = false;
 926
 927                         manager_set_server_name(m, f);
 928                 }
 929
 930                 /* Tell the resolver to reread /etc/resolv.conf, in
 931                  * case it changed. */
 932                 res_init();
 933
 934                 /* Flush out any previously resolved addresses */
 935                 server_name_flush_addresses(m->current_server_name);
 936
 937                 log_debug("Resolving %s...", m->current_server_name->string);
 938
 939                 r = sd_resolve_getaddrinfo(m->resolve, &m->resolve_query, m->current_server_name->string, "123", &hints, manager_resolve_handler, m);
 940                 if (r < 0) {
 941                         log_error("Failed to create resolver: %s", strerror(-r));
 942                         return r;
 943                 }
 944
 945                 return 1;
 946         }
 947
 948         r = manager_begin(m);
 949         if (r < 0)
 950                 return r;
 951
 952         return 1;
 953 }
 954
 955 void manager_disconnect(Manager *m) {
 956         assert(m);
 957
 958         m->resolve_query = sd_resolve_query_unref(m->resolve_query);
 959
 960         m->event_timer = sd_event_source_unref(m->event_timer);
 961
 962         m->event_receive = sd_event_source_unref(m->event_receive);
 963         m->server_socket = safe_close(m->server_socket);
 964
 965         m->event_clock_watch = sd_event_source_unref(m->event_clock_watch);
 966         m->clock_watch_fd = safe_close(m->clock_watch_fd);
 967
 968         m->event_timeout = sd_event_source_unref(m->event_timeout);
 969
 970         sd_notifyf(false, "STATUS=Idle.");
 971 }
 972
 973 void manager_flush_server_names(Manager  *m, ServerType t) {
 974         assert(m);
 975
 976         if (t == SERVER_SYSTEM)
 977                 while (m->system_servers)
 978                         server_name_free(m->system_servers);
 979
 980         if (t == SERVER_LINK)
 981                 while (m->link_servers)
 982                         server_name_free(m->link_servers);
 983
 984         if (t == SERVER_FALLBACK)
 985                 while (m->fallback_servers)
 986                         server_name_free(m->fallback_servers);
 987 }
 988
 989 void manager_free(Manager *m) {
 990         if (!m)
 991                 return;
 992
 993         manager_disconnect(m);
 994         manager_flush_server_names(m, SERVER_SYSTEM);
 995         manager_flush_server_names(m, SERVER_LINK);
 996         manager_flush_server_names(m, SERVER_FALLBACK);
 997
 998         sd_event_source_unref(m->event_retry);
 999
1000         sd_event_source_unref(m->network_event_source);
1001         sd_network_monitor_unref(m->network_monitor);
1002
1003         sd_resolve_unref(m->resolve);
1004         sd_event_unref(m->event);
1005
1006         free(m);
1007 }
1008
1009 static int manager_network_read_link_servers(Manager *m) {
1010         _cleanup_strv_free_ char **ntp = NULL;
1011         ServerName *n, *nx;
1012         char **i;
1013         int r;
1014
1015         assert(m);
1016
1017         r = sd_network_get_ntp(&ntp);
1018         if (r < 0)
1019                 goto clear;
1020
1021         LIST_FOREACH(names, n, m->link_servers)
1022                 n->marked = true;
1023
1024         STRV_FOREACH(i, ntp) {
1025                 bool found = false;
1026
1027                 LIST_FOREACH(names, n, m->link_servers)
1028                         if (streq(n->string, *i)) {
1029                                 n->marked = false;
1030                                 found = true;
1031                                 break;
1032                         }
1033
1034                 if (!found) {
1035                         r = server_name_new(m, NULL, SERVER_LINK, *i);
1036                         if (r < 0)
1037                                 goto clear;
1038                 }
1039         }
1040
1041         LIST_FOREACH_SAFE(names, n, nx, m->link_servers)
1042                 if (n->marked)
1043                         server_name_free(n);
1044
1045         return 0;
1046
1047 clear:
1048         manager_flush_server_names(m, SERVER_LINK);
1049         return r;
1050 }
1051
1052 static int manager_network_event_handler(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
1053         Manager *m = userdata;
1054         bool connected, online;
1055         int r;
1056
1057         assert(m);
1058
1059         sd_network_monitor_flush(m->network_monitor);
1060
1061         manager_network_read_link_servers(m);
1062
1063         /* check if the machine is online */
1064         online = network_is_online();
1065
1066         /* check if the client is currently connected */
1067         connected = m->server_socket >= 0 || m->resolve_query || m->exhausted_servers;
1068
1069         if (connected && !online) {
1070                 log_info("No network connectivity, watching for changes.");
1071                 manager_disconnect(m);
1072
1073         } else if (!connected && online) {
1074                 log_info("Network configuration changed, trying to establish connection.");
1075
1076                 if (m->current_server_address)
1077                         r = manager_begin(m);
1078                 else
1079                         r = manager_connect(m);
1080                 if (r < 0)
1081                         return r;
1082         }
1083
1084         return 0;
1085 }
1086
1087 static int manager_network_monitor_listen(Manager *m) {
1088         int r, fd, events;
1089
1090         assert(m);
1091
1092         r = sd_network_monitor_new(&m->network_monitor, NULL);
1093         if (r < 0)
1094                 return r;
1095
1096         fd = sd_network_monitor_get_fd(m->network_monitor);
1097         if (fd < 0)
1098                 return fd;
1099
1100         events = sd_network_monitor_get_events(m->network_monitor);
1101         if (events < 0)
1102                 return events;
1103
1104         r = sd_event_add_io(m->event, &m->network_event_source, fd, events, manager_network_event_handler, m);
1105         if (r < 0)
1106                 return r;
1107
1108         return 0;
1109 }
1110
1111 int manager_new(Manager **ret) {
1112         _cleanup_(manager_freep) Manager *m = NULL;
1113         int r;
1114
1115         assert(ret);
1116
1117         m = new0(Manager, 1);
1118         if (!m)
1119                 return -ENOMEM;
1120
1121         m->server_socket = m->clock_watch_fd = -1;
1122
1123         RATELIMIT_INIT(m->ratelimit, RATELIMIT_INTERVAL_USEC, RATELIMIT_BURST);
1124
1125         r = manager_parse_server_string(m, SERVER_FALLBACK, NTP_SERVERS);
1126         if (r < 0)
1127                 return r;
1128
1129         r = sd_event_default(&m->event);
1130         if (r < 0)
1131                 return r;
1132
1133         sd_event_add_signal(m->event, NULL, SIGTERM, NULL,  NULL);
1134         sd_event_add_signal(m->event, NULL, SIGINT, NULL, NULL);
1135
1136         sd_event_set_watchdog(m->event, true);
1137
1138         r = sd_resolve_default(&m->resolve);
1139         if (r < 0)
1140                 return r;
1141
1142         r = sd_resolve_attach_event(m->resolve, m->event, 0);
1143         if (r < 0)
1144                 return r;
1145
1146         r = manager_network_monitor_listen(m);
1147         if (r < 0)
1148                 return r;
1149
1150         manager_network_read_link_servers(m);
1151
1152         *ret = m;
1153         m = NULL;
1154
1155         return 0;
1156 }