src/timesync/timesyncd-manager.c

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