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