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