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