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